<!-- ##### FUNCTION gtk_invisible_new ##### -->
<para>
-Creates a new #GtkInvisible.
</para>
-@Returns: a new #GtkInvisible.
+@Returns:
<!-- ##### FUNCTION gtk_plug_construct ##### -->
<para>
-Finishes the creation of a #GtkPlug widget. This function
-will generally only be used by classes deriving
-from #GtkPlug.
</para>
-@plug: a #GtkPlug widget.
-@socket_id: the window ID of the socket.
+@plug:
+@socket_id:
<!-- ##### FUNCTION gtk_plug_new ##### -->
<para>
-Creates a new plug widget inside the #GtkSocket identified
-by @socket_id. If @socket_id is 0, the plug is left "unplugged" and
-can later be plugged into a #GtkSocket by gtk_socket_add_id().
</para>
@socket_id: the window ID of the socket, or 0.
GdkModifierType modifiers)
{
GSList *entries = NULL;
+ GdkDisplay *display;
GtkKeyHash *key_hash;
gboolean handled = FALSE;
gboolean is_release;
is_release = (modifiers & GDK_RELEASE_MASK) != 0;
modifiers = modifiers & BINDING_MOD_MASK () & ~GDK_RELEASE_MASK;
- key_hash = binding_key_hash_for_keymap (gdk_keymap_get_default ());
+ display = gtk_widget_get_display (GTK_WIDGET (object));
+ key_hash = binding_key_hash_for_keymap (gdk_keymap_get_for_display (display));
+
entries = _gtk_key_hash_lookup_keyval (key_hash, keyval, modifiers);
handled = gtk_bindings_activate_list (object, entries, is_release);
GdkEventKey *event)
{
GSList *entries = NULL;
+ GdkDisplay *display;
GtkKeyHash *key_hash;
gboolean handled = FALSE;
if (!GTK_IS_WIDGET (object))
return FALSE;
- key_hash = binding_key_hash_for_keymap (gdk_keymap_get_default ());
+ display = gtk_widget_get_display (GTK_WIDGET (object));
+ key_hash = binding_key_hash_for_keymap (gdk_keymap_get_for_display (display));
+
entries = _gtk_key_hash_lookup (key_hash,
event->hardware_keycode,
event->state & BINDING_MOD_MASK () & ~GDK_RELEASE_MASK,
g_source_remove (button->activate_timeout);
button->activate_timeout = 0;
- gdk_keyboard_ungrab (gtk_get_current_event_time ());
+ gdk_display_keyboard_ungrab (gtk_widget_get_display (widget),
+ gtk_get_current_event_time ());
gtk_grab_remove (widget);
button->button_down = FALSE;
guint32 timestamp;
gboolean have_selection;
+ GdkDisplay *display;
};
struct _RequestContentsInfo
GtkSelectionData *selection_data,
guint time);
-static GSList *clipboards;
-static GtkWidget *clipboard_widget;
-
enum {
TARGET_STRING,
TARGET_TEXT,
static const gchar *clipboards_owned_key = "gtk-clipboards-owned";
static GQuark clipboards_owned_key_id = 0;
-
/**
- * gtk_clipboard_get:
+ * gtk_clipboard_get_for_display:
+ * @display: the display for which the clipboard is to be retrieved or created
* @selection: a #GdkAtom which identifies the clipboard
* to use.
*
* Returns the clipboard object for the given selection.
* Cut/copy/paste menu items and keyboard shortcuts should use
- * the default clipboard, returned by passing #GDK_NONE for @selection.
+ * the default clipboard, returned by passing %GDK_SELECTION_CLIPBOARD for @selection.
+ * (%GDK_NONE is supported as a synonym for GDK_SELECTION_CLIPBOARD
+ * for backwards compatibility reasons.)
* The currently-selected object or text should be provided on the clipboard
* identified by #GDK_SELECTION_PRIMARY. Cut/copy/paste menu items
* conceptually copy the contents of the #GDK_SELECTION_PRIMARY clipboard
* cannot be freed.
**/
GtkClipboard *
-gtk_clipboard_get (GdkAtom selection)
+gtk_clipboard_get_for_display (GdkDisplay *display, GdkAtom selection)
{
GtkClipboard *clipboard = NULL;
+ GSList *clipboards;
GSList *tmp_list;
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+
if (selection == GDK_NONE)
- selection = gdk_atom_intern ("CLIPBOARD", FALSE);
+ selection = GDK_SELECTION_CLIPBOARD;
+
+ clipboards = g_object_get_data (G_OBJECT (display), "gtk-clipboard-list");
tmp_list = clipboards;
while (tmp_list)
{
clipboard = g_new0 (GtkClipboard, 1);
clipboard->selection = selection;
+ clipboard->display = display;
clipboards = g_slist_prepend (clipboards, clipboard);
+ g_object_set_data (G_OBJECT (display), "gtk-clipboard-list", clipboards);
}
return clipboard;
}
+/**
+ * gtk_clipboard_get():
+ * @selection: a #GdkAtom which identifies the clipboard
+ * to use.
+ *
+ * Returns the clipboard object for the given selection.
+ * See gtk_clipboard_get_for_display() for complete details.
+ *
+ * Return value: the appropriate clipboard object. If no
+ * clipboard already exists, a new one will
+ * be created. Once a clipboard object has
+ * been created, it is persistent for all time and
+ * cannot be freed.
+ **/
+GtkClipboard *
+gtk_clipboard_get (GdkAtom selection)
+{
+ return gtk_clipboard_get_for_display (gdk_get_default_display (), selection);
+}
+
static void
selection_get_cb (GtkWidget *widget,
GtkSelectionData *selection_data,
guint time,
guint info)
{
- GtkClipboard *clipboard = gtk_clipboard_get (selection_data->selection);
+ GtkClipboard *clipboard = gtk_widget_get_clipboard (widget, selection_data->selection);
if (clipboard && clipboard->get_func)
clipboard->get_func (clipboard, selection_data, info, clipboard->user_data);
selection_clear_event_cb (GtkWidget *widget,
GdkEventSelection *event)
{
- GtkClipboard *clipboard = gtk_clipboard_get (event->selection);
+ GtkClipboard *clipboard = gtk_widget_get_clipboard (widget, event->selection);
if (clipboard)
{
}
static GtkWidget *
-make_clipboard_widget (gboolean provider)
+make_clipboard_widget (GdkDisplay *display,
+ gboolean provider)
{
- GtkWidget *widget = gtk_invisible_new ();
+ GtkWidget *widget = gtk_invisible_new_for_screen (gdk_display_get_default_screen (display));
gtk_signal_connect (GTK_OBJECT (widget), "selection_received",
GTK_SIGNAL_FUNC (selection_received), NULL);
return widget;
}
-
-static void
-ensure_clipboard_widget ()
+static GtkWidget *
+get_clipboard_widget (GdkDisplay *display)
{
- if (!clipboard_widget)
- clipboard_widget = make_clipboard_widget (TRUE);
+ GtkWidget *clip_widget = g_object_get_data (G_OBJECT (display), "gtk-clipboard-widget");
+ if (!clip_widget)
+ {
+ clip_widget = make_clipboard_widget (display, TRUE);
+ g_object_set_data (G_OBJECT (display), "gtk-clipboard-widget", clip_widget);
+ }
+
+ return clip_widget;
}
/* This function makes a very good guess at what the correct
static guint32
clipboard_get_timestamp (GtkClipboard *clipboard)
{
+ GtkWidget *clipboard_widget = get_clipboard_widget (clipboard->display);
guint32 timestamp = gtk_get_current_event_time ();
- ensure_clipboard_widget ();
-
if (timestamp == GDK_CURRENT_TIME)
{
#ifdef GDK_WINDOWING_X11
gpointer user_data,
gboolean have_owner)
{
- ensure_clipboard_widget ();
+ GtkWidget *clipboard_widget = get_clipboard_widget (clipboard->display);
- if (gtk_selection_owner_set (clipboard_widget, clipboard->selection,
- clipboard_get_timestamp (clipboard)))
+ if (gtk_selection_owner_set_for_display (clipboard->display,
+ clipboard_widget,
+ clipboard->selection,
+ clipboard_get_timestamp (clipboard)))
{
clipboard->have_selection = TRUE;
g_return_if_fail (clipboard != NULL);
if (clipboard->have_selection)
- gtk_selection_owner_set (NULL, clipboard->selection,
- clipboard_get_timestamp (clipboard));
+ gtk_selection_owner_set_for_display (clipboard->display,
+ NULL,
+ clipboard->selection,
+ clipboard_get_timestamp (clipboard));
}
static void
RequestContentsInfo *request_info = get_request_contents_info (widget);
set_request_contents_info (widget, NULL);
- request_info->callback (gtk_clipboard_get (selection_data->selection),
+ request_info->callback (gtk_widget_get_clipboard (widget, selection_data->selection),
selection_data,
request_info->user_data);
g_free (request_info);
- if (widget != clipboard_widget)
+ if (widget != get_clipboard_widget (gtk_widget_get_display (widget)))
gtk_widget_destroy (widget);
}
{
RequestContentsInfo *info;
GtkWidget *widget;
+ GtkWidget *clipboard_widget;
g_return_if_fail (clipboard != NULL);
g_return_if_fail (target != GDK_NONE);
g_return_if_fail (callback != NULL);
- ensure_clipboard_widget ();
+ clipboard_widget = get_clipboard_widget (clipboard->display);
if (get_request_contents_info (clipboard_widget))
- widget = make_clipboard_widget (FALSE);
+ widget = make_clipboard_widget (clipboard->display, FALSE);
else
widget = clipboard_widget;
return results.data;
}
+/**
+ * gtk_clipboard_get_display:
+ * @clipboard: a #GtkClipboard
+ *
+ * Gets the #GdkDisplay associated with @clipboard
+ *
+ * Return value: the #GdkDisplay associated with @clipboard
+ **/
+GdkDisplay *
+gtk_clipboard_get_display (GtkClipboard *clipboard)
+{
+ g_return_val_if_fail (clipboard != NULL, NULL);
+
+ return clipboard->display;
+}
/**
* gtk_clipboard_wait_is_text_available:
#include <gtk/gtkselection.h>
-typedef struct _GtkClipboard GtkClipboard;
typedef void (* GtkClipboardReceivedFunc) (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
gpointer user_data_or_owner);
typedef void (* GtkClipboardClearFunc) (GtkClipboard *clipboard,
gpointer user_data_or_owner);
-
-GtkClipboard *gtk_clipboard_get (GdkAtom selection);
+
+GtkClipboard *gtk_clipboard_get_for_display (GdkDisplay *display,
+ GdkAtom selection);
+#ifndef GDK_MULTIHEAD_SAFE
+GtkClipboard *gtk_clipboard_get (GdkAtom selection);
+#endif
+
+GdkDisplay *gtk_clipboard_get_display (GtkClipboard *clipboard);
+
gboolean gtk_clipboard_set_with_data (GtkClipboard *clipboard,
const GtkTargetEntry *targets,
GTK_CLIST_UNSET_FLAG (clist, CLIST_IN_DRAG);
gtk_grab_remove (GTK_WIDGET (clist));
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (GTK_WIDGET (clist)),
+ GDK_CURRENT_TIME);
clist->drag_pos = -1;
if (clist->x_drag >= 0 && clist->x_drag <= clist->clist_window_width - 1)
GTK_CLIST_ROW (work));
}
+static gboolean
+clist_has_grab (GtkCList *clist)
+{
+ return (GTK_WIDGET_HAS_GRAB (clist) &&
+ gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (clist))));
+}
+
static void
toggle_focus_row (GtkCList *clist)
{
g_return_if_fail (clist != 0);
g_return_if_fail (GTK_IS_CLIST (clist));
- if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)) ||
+ if (clist_has_grab (clist) ||
clist->focus_row < 0 || clist->focus_row >= clist->rows)
return;
g_return_if_fail (clist != 0);
g_return_if_fail (GTK_IS_CLIST (clist));
- if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)) ||
+ if (clist_has_grab (clist) ||
clist->selection_mode != GTK_SELECTION_MULTIPLE)
return;
{
g_return_if_fail (GTK_IS_CLIST (clist));
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
+ if (clist_has_grab (clist))
return;
switch (clist->selection_mode)
g_return_if_fail (GTK_IS_CLIST (clist));
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
+ if (clist_has_grab (clist))
return;
switch (clist->selection_mode)
g_return_if_fail (GTK_IS_CLIST (clist));
- if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)) ||
+ if (clist_has_grab (clist) ||
clist->selection_mode != GTK_SELECTION_MULTIPLE)
return;
{
g_return_if_fail (GTK_IS_CLIST (clist));
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
+ if (clist_has_grab (clist))
return;
set_anchor (clist, GTK_CLIST_ADD_MODE(clist), clist->focus_row,
{
g_return_if_fail (GTK_IS_CLIST (clist));
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_FOCUS(clist))
+ if (gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (clist))) &&
+ GTK_WIDGET_HAS_FOCUS (clist))
return;
GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
{
g_return_if_fail (GTK_IS_CLIST (clist));
- if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)) ||
+ if (clist_has_grab (clist) ||
clist->selection_mode != GTK_SELECTION_MULTIPLE)
return;
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK);
attributes_mask = GDK_WA_CURSOR;
- attributes.cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
+ attributes.cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (widget),
+ GDK_SB_H_DOUBLE_ARROW);
clist->cursor_drag = attributes.cursor;
attributes.x = LIST_WIDTH (clist) + 1;
{
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
+ if (clist_has_grab (clist))
{
remove_grab (clist);
GTK_CLIST_UNSET_FLAG (clist, CLIST_IN_DRAG);
gtk_widget_get_pointer (widget, &x, NULL);
gtk_grab_remove (widget);
- gdk_pointer_ungrab (event->time);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (widget), event->time);
if (clist->x_drag >= 0)
draw_xor_line (clist);
g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
clist = GTK_CLIST (widget);
- if (!(gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)))
+ if (!clist_has_grab (clist))
return FALSE;
if (clist->drag_button > 0)
g_return_if_fail (clist != 0);
g_return_if_fail (GTK_IS_CLIST (clist));
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
+ if (clist_has_grab (clist))
return;
for (last_column = clist->columns - 1;
g_return_if_fail (GTK_IS_CLIST (clist));
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
+ if (clist_has_grab (clist))
return;
switch (clist->selection_mode)
static void
remove_grab (GtkCList *clist)
{
+ GtkWidget *widget = GTK_WIDGET (clist);
+
if (GTK_WIDGET_HAS_GRAB (clist))
{
- gtk_grab_remove (GTK_WIDGET (clist));
- if (gdk_pointer_is_grabbed ())
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
+ GdkDisplay *display = gtk_widget_get_display (widget);
+
+ gtk_grab_remove (widget);
+ if (gdk_display_pointer_is_grabbed (display))
+ gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
}
if (clist->htimer)
if (clist->rows <= 1)
return;
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
+ if (clist_has_grab (clist))
return;
gtk_clist_freeze (clist);
if (button < MAX_BUTTON)
{
- if (gdk_pointer_is_grabbed () || GTK_WIDGET_HAS_GRAB (clist))
+ if (gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (clist))) ||
+ GTK_WIDGET_HAS_GRAB (clist))
{
remove_grab (clist);
clist->drag_button = 0;
#include "gtkmain.h"
#include "gtksettings.h"
#include "gtkintl.h"
+#include "gtkimage.h"
#include <string.h>
static void gtk_color_selection_init (GtkColorSelection *colorsel);
static void gtk_color_selection_class_init (GtkColorSelectionClass *klass);
static void gtk_color_selection_destroy (GtkObject *object);
-static void gtk_color_selection_finalize (GObject *object);
-static void gtk_color_selection_realize (GtkWidget *widget);
static void update_color (GtkColorSelection *colorsel);
static void gtk_color_selection_set_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
+static void gtk_color_selection_realize (GtkWidget *widget);
+static void gtk_color_selection_unrealize (GtkWidget *widget);
+
static gint gtk_color_selection_get_palette_size (GtkColorSelection *colorsel);
static gboolean gtk_color_selection_get_palette_color (GtkColorSelection *colorsel,
gint index,
gint index);
static GdkGC *get_focus_gc (GtkWidget *drawing_area,
gint *focus_width);
-static void default_change_palette_func (const GdkColor *colors,
+static void default_noscreen_change_palette_func (const GdkColor *colors,
+ gint n_colors);
+static void default_change_palette_func (GdkScreen *screen,
+ const GdkColor *colors,
gint n_colors);
static gpointer parent_class = NULL;
static gchar* default_colors = "black:white:gray50:red:purple:blue:light blue:green:yellow:orange:lavender:brown:goldenrod4:dodger blue:pink:light green:gray10:gray30:gray75:gray90";
-static GtkColorSelectionChangePaletteFunc change_palette_hook = default_change_palette_func;
-
-static GdkColor current_colors[GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT];
+static GtkColorSelectionChangePaletteFunc noscreen_change_palette_hook = default_noscreen_change_palette_func;
+static GtkColorSelectionChangePaletteWithScreenFunc change_palette_hook = default_change_palette_func;
/* The cursor for the dropper */
#define DROPPER_WIDTH 17
0x7c, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x0d, 0x00, 0x00,
0x02, 0x00, 0x00, };
-static GdkCursor *picker_cursor = NULL;
-
/* XPM */
static char *picker[] = {
priv = colorsel->private_data;
window = gtk_window_new (GTK_WINDOW_POPUP);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
gtk_widget_set_usize (window, 48, 32);
gtk_widget_realize (window);
priv = colorsel->private_data;
window = gtk_window_new (GTK_WINDOW_POPUP);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
gtk_widget_set_usize (window, 48, 32);
gtk_widget_realize (window);
gtk_object_set_data (GTK_OBJECT (widget), "gtk-color-selection-drag-window", NULL);
}
+static GdkColor *
+get_current_colors (GtkColorSelection *colorsel)
+{
+ GtkSettings *settings;
+ GdkColor *colors = NULL;
+ gint n_colors = 0;
+ gchar *palette;
+
+ settings = gtk_widget_get_settings (GTK_WIDGET (colorsel));
+ g_object_get (G_OBJECT (settings),
+ "gtk-color-palette", &palette,
+ NULL);
+
+ if (!gtk_color_selection_palette_from_string (palette, &colors, &n_colors))
+ {
+ gtk_color_selection_palette_from_string (default_colors, &colors, &n_colors);
+ }
+ else
+ {
+ /* If there are less colors provided than the number of slots in the
+ * color selection, we fill in the rest from the defaults.
+ */
+ if (n_colors < (GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT))
+ {
+ GdkColor *tmp_colors = colors;
+ gint tmp_n_colors = n_colors;
+
+ gtk_color_selection_palette_from_string (default_colors, &colors, &n_colors);
+ memcpy (colors, tmp_colors, sizeof (GdkColor) * tmp_n_colors);
+
+ g_free (tmp_colors);
+ }
+ }
+
+ g_assert (n_colors >= GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT);
+ g_free (palette);
+
+ return colors;
+}
+
/* Changes the model color */
static void
palette_change_color (GtkWidget *drawing_area,
gint x, y;
ColorSelectionPrivate *priv;
GdkColor gdk_color;
+ GdkColor *current_colors;
+ GdkScreen *screen;
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
g_return_if_fail (GTK_IS_DRAWING_AREA (drawing_area));
g_assert (x < GTK_CUSTOM_PALETTE_WIDTH || y < GTK_CUSTOM_PALETTE_HEIGHT);
+ current_colors = get_current_colors (colorsel);
current_colors[y * GTK_CUSTOM_PALETTE_WIDTH + x] = gdk_color;
- if (change_palette_hook)
- (* change_palette_hook) (current_colors, GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT);
+ screen = gtk_widget_get_screen (GTK_WIDGET (colorsel));
+ if (change_palette_hook != default_change_palette_func)
+ (* change_palette_hook) (screen, current_colors,
+ GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT);
+ else if (noscreen_change_palette_hook != default_noscreen_change_palette_func)
+ {
+ if (screen != gdk_get_default_screen ())
+ g_warning ("gtk_color_selection_set_change_palette_hook used by widget is not on the default screen.");
+ (* noscreen_change_palette_hook) (current_colors,
+ GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT);
+ }
+ else
+ (* change_palette_hook) (screen, current_colors,
+ GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT);
+
+ g_free (current_colors);
}
/* Changes the view color */
GtkWidget *widget;
GtkRequisition req;
gint root_x, root_y;
+ GdkScreen *screen;
widget = GTK_WIDGET (user_data);
*y = root_y + widget->allocation.height / 2;
/* Ensure sanity */
- *x = CLAMP (*x, 0, MAX (0, gdk_screen_width () - req.width));
- *y = CLAMP (*y, 0, MAX (0, gdk_screen_height () - req.height));
+ screen = gtk_widget_get_screen (widget);
+ *x = CLAMP (*x, 0, MAX (0, gdk_screen_get_width (screen) - req.width));
+ *y = CLAMP (*y, 0, MAX (0, gdk_screen_get_height (screen) - req.height));
}
static void
*
*/
-static void
-initialize_cursor (void)
+static GdkCursor *
+make_picker_cursor (GdkScreen *screen)
{
+ GdkCursor *cursor;
GdkColor fg, bg;
GdkPixmap *pixmap =
- gdk_bitmap_create_from_data (NULL,
- dropper_bits,
- DROPPER_WIDTH, DROPPER_HEIGHT);
+ gdk_bitmap_create_from_data (gdk_screen_get_root_window (screen),
+ dropper_bits, DROPPER_WIDTH, DROPPER_HEIGHT);
+
GdkPixmap *mask =
- gdk_bitmap_create_from_data (NULL,
- dropper_mask,
- DROPPER_WIDTH, DROPPER_HEIGHT);
+ gdk_bitmap_create_from_data (gdk_screen_get_root_window (screen),
+ dropper_mask, DROPPER_WIDTH, DROPPER_HEIGHT);
+
- gdk_color_white (gdk_colormap_get_system (), &bg);
- gdk_color_black (gdk_colormap_get_system (), &fg);
+ gdk_color_white (gdk_screen_get_system_colormap (screen), &bg);
+ gdk_color_black (gdk_screen_get_system_colormap (screen), &fg);
- picker_cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &fg, &bg, DROPPER_X_HOT ,DROPPER_Y_HOT);
+ cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &fg, &bg, DROPPER_X_HOT ,DROPPER_Y_HOT);
gdk_pixmap_unref (pixmap);
gdk_pixmap_unref (mask);
-
+
+ return cursor;
}
static void
guint32 pixel;
GtkColorSelection *colorsel = data;
ColorSelectionPrivate *priv;
- GdkColormap *colormap = gdk_colormap_get_system ();
GdkColor color;
+ GdkColormap *colormap = gdk_screen_get_system_colormap (gtk_widget_get_screen (invisible));
+ GdkWindow *root_window = gdk_screen_get_root_window (gtk_widget_get_screen (invisible));
priv = colorsel->private_data;
- image = gdk_image_get (GDK_ROOT_PARENT (), x_root, y_root, 1, 1);
+ image = gdk_image_get (root_window, x_root, y_root, 1, 1);
pixel = gdk_image_get_pixel (image, 0, 0);
gdk_image_unref (image);
{
GtkColorSelection *colorsel;
ColorSelectionPrivate *priv;
+ GdkDisplay *display = gtk_widget_get_display (widget);
+ guint32 time = gtk_get_current_event_time ();
colorsel = GTK_COLOR_SELECTION (widget);
priv = colorsel->private_data;
- gdk_keyboard_ungrab (gtk_get_current_event_time ());
- gdk_pointer_ungrab (gtk_get_current_event_time ());
+ gdk_display_keyboard_ungrab (display, time);
+ gdk_display_pointer_ungrab (display, time);
gtk_grab_remove (priv->dropper_grab_widget);
}
get_screen_color (GtkWidget *button)
{
GtkColorSelection *colorsel = gtk_object_get_data (GTK_OBJECT (button), "COLORSEL");
- ColorSelectionPrivate *priv = colorsel->private_data;
+ ColorSelectionPrivate *priv = colorsel->private_data;
+ GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (button));
+ GdkCursor *picker_cursor;
+ GdkGrabStatus grab_status;
- if (picker_cursor == NULL)
- {
- initialize_cursor ();
- }
-
if (priv->dropper_grab_widget == NULL)
{
- priv->dropper_grab_widget = gtk_invisible_new ();
+ priv->dropper_grab_widget = gtk_invisible_new_for_screen (screen);
gtk_widget_add_events (priv->dropper_grab_widget,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
return;
}
- if (gdk_pointer_grab (priv->dropper_grab_widget->window,
- FALSE,
- GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK,
- NULL,
- picker_cursor,
- gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
+ picker_cursor = make_picker_cursor (screen);
+ grab_status = gdk_pointer_grab (priv->dropper_grab_widget->window,
+ FALSE,
+ GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK,
+ NULL,
+ picker_cursor,
+ gtk_get_current_event_time ());
+ gdk_cursor_unref (picker_cursor);
+
+ if (grab_status != GDK_GRAB_SUCCESS)
{
- gdk_keyboard_ungrab (GDK_CURRENT_TIME);
+ gdk_display_keyboard_ungrab (gtk_widget_get_display (button), GDK_CURRENT_TIME);
g_warning ("Failed to grab pointer to do eyedropper");
return;
}
g_object_unref (colorsel);
}
-
-static void
-fill_palette_from_string (const gchar *str)
-{
- GdkColor *colors = NULL;
- gint n_colors = 0;
-
- if (str == NULL)
- return;
-
- if (!gtk_color_selection_palette_from_string (str, &colors, &n_colors))
- return;
-
- if (n_colors > (GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT))
- n_colors = GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT;
-
- memcpy (current_colors, colors, sizeof (GdkColor) * n_colors);
-
- g_free (colors);
-}
-
-static void
-palette_change_notify_class (GObject *object,
- GParamSpec *pspec)
-{
- gchar *str = NULL;
-
- g_object_get (object, pspec->name, &str, NULL);
-
- fill_palette_from_string (str);
-
- g_free (str);
-}
-
static void
update_palette (GtkColorSelection *colorsel)
{
+ GdkColor *current_colors;
gint i, j;
+
+ current_colors = get_current_colors (colorsel);
for (i = 0; i < GTK_CUSTOM_PALETTE_HEIGHT; i++)
{
¤t_colors[index]);
}
}
+
+ g_free (current_colors);
}
static void
}
static void
-default_change_palette_func (const GdkColor *colors,
+default_noscreen_change_palette_func (const GdkColor *colors,
+ gint n_colors)
+{
+ default_change_palette_func (gdk_get_default_screen (), colors, n_colors);
+}
+
+static void
+default_change_palette_func (GdkScreen *screen,
+ const GdkColor *colors,
gint n_colors)
{
gchar *str;
str = gtk_color_selection_palette_to_string (colors, n_colors);
- gtk_settings_set_string_property (gtk_settings_get_default (),
+ gtk_settings_set_string_property (gtk_settings_get_for_screen (screen),
"gtk-color-palette",
str,
"gtk_color_selection_palette_to_string");
parent_class = gtk_type_class (GTK_TYPE_VBOX);
object_class->destroy = gtk_color_selection_destroy;
- gobject_class->finalize = gtk_color_selection_finalize;
gobject_class->set_property = gtk_color_selection_set_property;
gobject_class->get_property = gtk_color_selection_get_property;
-
- widget_class->realize = gtk_color_selection_realize;
+ widget_class->realize = gtk_color_selection_realize;
+ widget_class->unrealize = gtk_color_selection_unrealize;
+
g_object_class_install_property (gobject_class,
PROP_HAS_OPACITY_CONTROL,
g_param_spec_boolean ("has_opacity_control",
{
GtkWidget *top_hbox;
GtkWidget *top_right_vbox;
- GtkWidget *table, *label, *hbox, *frame, *vbox;
+ GtkWidget *table, *label, *hbox, *frame, *vbox, *button;
GtkAdjustment *adjust;
- GdkPixmap *dropper_pixmap;
- GtkWidget *dropper_image;
- GtkWidget *button;
- GdkBitmap *mask = NULL;
+ GdkPixbuf *picker_pix = NULL;
+ GtkWidget *picker_image;
gint i, j;
ColorSelectionPrivate *priv;
gtk_object_set_data (GTK_OBJECT (button), "COLORSEL", colorsel);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (get_screen_color), NULL);
- dropper_pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL, gtk_widget_get_colormap (button), &mask, NULL, picker);
- dropper_image = gtk_pixmap_new (dropper_pixmap, mask);
- gdk_pixmap_unref (dropper_pixmap);
- if (mask)
- gdk_pixmap_unref (mask);
- gtk_container_add (GTK_CONTAINER (button), dropper_image);
+ picker_pix = gdk_pixbuf_new_from_xpm_data ((const char **) &picker);
+ picker_image = gtk_image_new_from_pixbuf (picker_pix);
+ gtk_container_add (GTK_CONTAINER (button), picker_image);
+ gtk_widget_show (GTK_WIDGET (picker_image));
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_tooltips_set_tip (priv->tooltips,
}
static void
-gtk_color_selection_finalize (GObject *object)
+gtk_color_selection_realize (GtkWidget *widget)
{
- GtkColorSelection *cselection = GTK_COLOR_SELECTION (object);
-
- if (cselection->private_data)
- {
- ColorSelectionPrivate *priv;
+ GtkColorSelection *colorsel = GTK_COLOR_SELECTION (widget);
+ ColorSelectionPrivate *priv = colorsel->private_data;
+ GtkSettings *settings = gtk_widget_get_settings (widget);
- priv = cselection->private_data;
+ priv->settings_connection = g_signal_connect (settings,
+ "notify::gtk-color-palette",
+ G_CALLBACK (palette_change_notify_instance),
+ widget);
+ update_palette (colorsel);
- if (priv->settings_connection)
- g_signal_handler_disconnect (gtk_settings_get_default (),
- priv->settings_connection);
-
- g_free (cselection->private_data);
- cselection->private_data = NULL;
- }
-
- G_OBJECT_CLASS (parent_class)->finalize (object);
+ GTK_WIDGET_CLASS (parent_class)->realize (widget);
}
static void
-gtk_color_selection_realize (GtkWidget *widget)
+gtk_color_selection_unrealize (GtkWidget *widget)
{
GtkColorSelection *colorsel = GTK_COLOR_SELECTION (widget);
ColorSelectionPrivate *priv = colorsel->private_data;
- gchar *palette;
- static gboolean initialized = FALSE;
-
- if (!initialized)
- {
- g_object_get (gtk_settings_get_default (),
- "gtk-color-palette", &palette,
- NULL);
-
- fill_palette_from_string (palette);
- g_free (palette);
-
- g_signal_connect (gtk_settings_get_default (),
- "notify::gtk-color-palette",
- G_CALLBACK (palette_change_notify_class),
- NULL);
-
- initialized = TRUE;
- }
-
- /* Set default colors */
+ GtkSettings *settings = gtk_widget_get_settings (widget);
- update_palette (colorsel);
- priv->settings_connection =
- g_signal_connect (gtk_settings_get_default (),
- "notify::gtk-color-palette",
- G_CALLBACK (palette_change_notify_instance),
- colorsel);
+ g_signal_handler_disconnect (settings, priv->settings_connection);
- if (GTK_WIDGET_CLASS (parent_class)->realize)
- GTK_WIDGET_CLASS (parent_class)->realize (widget);
+ GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
}
/**
* modify the palette in a color selection. This function should save
* the new palette contents, and update the GtkSettings property
* "gtk-color-palette" so all GtkColorSelection widgets will be modified.
+ *
+ * This function is deprecated in favor of
+ * gtk_color_selection_set_change_palette_with_screen_hook(), and does
+ * not work in multihead environments.
*
* Return value: the previous change palette hook (that was replaced).
**/
{
GtkColorSelectionChangePaletteFunc old;
+ old = noscreen_change_palette_hook;
+
+ noscreen_change_palette_hook = func;
+
+ return old;
+}
+
+/**
+ * gtk_color_selection_set_change_palette_hook:
+ * @func: a function to call when the custom palette needs saving.
+ *
+ * Installs a global function to be called whenever the user tries to
+ * modify the palette in a color selection. This function should save
+ * the new palette contents, and update the GtkSettings property
+ * "gtk-color-palette" so all GtkColorSelection widgets will be modified.
+ *
+ * Return value: the previous change palette hook (that was replaced).
+ **/
+GtkColorSelectionChangePaletteWithScreenFunc
+gtk_color_selection_set_change_palette_with_screen_hook (GtkColorSelectionChangePaletteWithScreenFunc func)
+{
+ GtkColorSelectionChangePaletteWithScreenFunc old;
+
old = change_palette_hook;
change_palette_hook = func;
typedef void (* GtkColorSelectionChangePaletteFunc) (const GdkColor *colors,
gint n_colors);
+typedef void (* GtkColorSelectionChangePaletteWithScreenFunc) (GdkScreen *screen,
+ const GdkColor *colors,
+ gint n_colors);
struct _GtkColorSelection
{
gchar* gtk_color_selection_palette_to_string (const GdkColor *colors,
gint n_colors);
-GtkColorSelectionChangePaletteFunc gtk_color_selection_set_change_palette_hook (GtkColorSelectionChangePaletteFunc func);
+#ifndef GDK_MULTIHEAD_SAFE
+GtkColorSelectionChangePaletteFunc gtk_color_selection_set_change_palette_hook (GtkColorSelectionChangePaletteFunc func);
+#endif
+
+GtkColorSelectionChangePaletteWithScreenFunc gtk_color_selection_set_change_palette_with_screen_hook (GtkColorSelectionChangePaletteWithScreenFunc func);
#ifndef GTK_DISABLE_DEPRECATED
/* Deprecated calls: */
static void gtk_combo_class_init (GtkComboClass *klass);
static void gtk_combo_init (GtkCombo *combo);
+static void gtk_combo_realize (GtkWidget *widget);
+static void gtk_combo_unrealize (GtkWidget *widget);
static void gtk_combo_destroy (GtkObject *combo);
static GtkListItem *gtk_combo_find (GtkCombo *combo);
static gchar * gtk_combo_func (GtkListItem *li);
oclass->destroy = gtk_combo_destroy;
widget_class->size_allocate = gtk_combo_size_allocate;
+ widget_class->realize = gtk_combo_realize;
+ widget_class->unrealize = gtk_combo_unrealize;
}
static void
if (GTK_WIDGET_HAS_GRAB (combo->popwin))
{
gtk_grab_remove (combo->popwin);
- gdk_pointer_ungrab (event->time);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (window),
+ event->time);
}
}
real_height = MIN (combo->entry->requisition.height,
combo->entry->allocation.height);
*y += real_height;
- avail_height = gdk_screen_height () - *y;
+ avail_height = gdk_screen_get_height (gtk_widget_get_screen (widget)) - *y;
gtk_widget_size_request (combo->list, &list_requisition);
min_height = MIN (list_requisition.height,
if (GTK_WIDGET_HAS_GRAB (combo->popwin))
{
gtk_grab_remove (combo->popwin);
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (GTK_WIDGET (combo)),
+ GDK_CURRENT_TIME);
}
gtk_widget_hide (combo->popwin);
return FALSE;
}
+static void
+combo_event_box_realize (GtkWidget *widget)
+{
+ GdkCursor *cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (widget),
+ GDK_TOP_LEFT_ARROW);
+ gdk_window_set_cursor (widget->window, cursor);
+ gdk_cursor_destroy (cursor);
+}
+
static void
gtk_combo_init (GtkCombo * combo)
{
GtkWidget *arrow;
GtkWidget *frame;
GtkWidget *event_box;
- GdkCursor *cursor;
combo->case_sensitive = FALSE;
combo->value_in_list = FALSE;
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (combo->popwin), event_box);
+ g_signal_connect (event_box, "realize",
+ G_CALLBACK (combo_event_box_realize), NULL);
gtk_widget_show (event_box);
- gtk_widget_realize (event_box);
- cursor = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
- gdk_window_set_cursor (event_box->window, cursor);
- gdk_cursor_destroy (cursor);
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (event_box), frame);
GTK_SIGNAL_FUNC (gtk_combo_list_enter), combo);
}
+static void
+gtk_combo_realize (GtkWidget *widget)
+{
+ GtkCombo *combo = GTK_COMBO (widget);
+
+ gtk_window_set_screen (GTK_WINDOW (combo->popwin),
+ gtk_widget_get_screen (widget));
+
+ GTK_WIDGET_CLASS( parent_class )->realize (widget);
+}
+
+static void
+gtk_combo_unrealize (GtkWidget *widget)
+{
+ GtkCombo *combo = GTK_COMBO (widget);
+
+ gtk_combo_popdown_list (combo);
+ gtk_widget_unrealize (combo->popwin);
+
+ GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
+}
+
GtkType
gtk_combo_get_type (void)
{
clist = GTK_CLIST (ctree);
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (ctree))
+ if (gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (ctree))) &&
+ GTK_WIDGET_HAS_GRAB (ctree))
return;
if (!(node =
static void
remove_grab (GtkCList *clist)
{
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
+ if (gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (clist))) &&
+ GTK_WIDGET_HAS_GRAB (clist))
{
gtk_grab_remove (GTK_WIDGET (clist));
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (GTK_WIDGET (clist)),
+ GDK_CURRENT_TIME);
}
if (clist->htimer)
c->cursor_type = new_type;
- cursor = gdk_cursor_new (c->cursor_type);
+ cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (w),
+ c->cursor_type);
gdk_window_set_cursor (w->window, cursor);
gdk_cursor_destroy (cursor);
}
{
gint width, height;
gfloat aspect;
+ GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (curve));
width = (curve->max_x - curve->min_x) + 1;
height = (curve->max_y - curve->min_y) + 1;
aspect = width / (gfloat) height;
- if (width > gdk_screen_width () / 4)
- width = gdk_screen_width () / 4;
- if (height > gdk_screen_height () / 4)
- height = gdk_screen_height () / 4;
+ if (width > gdk_screen_get_width (screen) / 4)
+ width = gdk_screen_get_width (screen) / 4;
+ if (height > gdk_screen_get_height (screen) / 4)
+ height = gdk_screen_get_height (screen) / 4;
if (aspect < 1.0)
width = height * aspect;
GtkCurveType old_type;
gfloat rx, dx, ry;
gint i, height;
+ GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (c));
old_type = c->curve_type;
c->curve_type = GTK_CURVE_TYPE_FREE;
else
{
height = (c->max_y - c->min_y);
- if (height > gdk_screen_height () / 4)
- height = gdk_screen_height () / 4;
+ if (height > gdk_screen_get_height (screen) / 4)
+ height = gdk_screen_get_height (screen) / 4;
c->height = height;
c->num_points = veclen;
#include "gtkstock.h"
#include "gtkwindow.h"
-static GSList *drag_widgets = NULL;
static GSList *source_widgets = NULL;
typedef struct _GtkDragSourceSite GtkDragSourceSite;
GdkDragAction actions,
GdkDragAction *suggested_action,
GdkDragAction *possible_actions);
-static GdkCursor * gtk_drag_get_cursor (GdkDragAction action);
-static GtkWidget *gtk_drag_get_ipc_widget (void);
+static GdkCursor * gtk_drag_get_cursor (GdkScreen *screen,
+ GdkDragAction action);
+static GtkWidget *gtk_drag_get_ipc_widget (GdkScreen *screen);
static void gtk_drag_release_ipc_widget (GtkWidget *widget);
static gboolean gtk_drag_highlight_expose (GtkWidget *widget,
*************************************************************/
static GtkWidget *
-gtk_drag_get_ipc_widget (void)
+gtk_drag_get_ipc_widget (GdkScreen *screen)
{
GtkWidget *result;
+ GSList *drag_widgets = g_object_get_data (G_OBJECT (screen),
+ "gtk-dnd-ipc-widgets");
if (drag_widgets)
{
GSList *tmp = drag_widgets;
result = drag_widgets->data;
drag_widgets = drag_widgets->next;
+ g_object_set_data (G_OBJECT (screen),
+ "gtk-dnd-ipc-widgets",
+ drag_widgets);
g_slist_free_1 (tmp);
}
else
{
- result = gtk_invisible_new ();
+ result = gtk_invisible_new_for_screen (screen);
gtk_widget_show (result);
}
static void
gtk_drag_release_ipc_widget (GtkWidget *widget)
{
+ GdkScreen *screen = gtk_widget_get_screen (widget);
+ GSList *drag_widgets = g_object_get_data (G_OBJECT (screen),
+ "gtk-dnd-ipc-widgets");
drag_widgets = g_slist_prepend (drag_widgets, widget);
+ g_object_set_data (G_OBJECT (screen),
+ "gtk-dnd-ipc-widgets",
+ drag_widgets);
}
static guint32
}
static GdkCursor *
-gtk_drag_get_cursor (GdkDragAction action)
+gtk_drag_get_cursor (GdkScreen *screen,
+ GdkDragAction action)
{
gint i;
for (i = 0 ; i < n_drag_cursors - 1; i++)
if (drag_cursors[i].action == action)
break;
+ if (drag_cursors[i].cursor != NULL)
+ {
+ if (screen != gdk_cursor_get_screen (drag_cursors[i].cursor))
+ {
+ gdk_cursor_unref (drag_cursors[i].cursor);
+ drag_cursors[i].cursor = NULL;
+ }
+ }
if (drag_cursors[i].cursor == NULL)
{
+ GdkColormap *colormap;
GdkColor fg, bg;
GdkPixmap *pixmap =
- gdk_bitmap_create_from_data (NULL,
- drag_cursors[i].bits,
- CURSOR_WIDTH, CURSOR_HEIGHT);
+ gdk_bitmap_create_from_data (gdk_screen_get_root_window (screen),
+ drag_cursors[i].bits, CURSOR_WIDTH, CURSOR_HEIGHT);
+
GdkPixmap *mask =
- gdk_bitmap_create_from_data (NULL,
- drag_cursors[i].mask,
- CURSOR_WIDTH, CURSOR_HEIGHT);
+ gdk_bitmap_create_from_data (gdk_screen_get_root_window (screen),
+ drag_cursors[i].mask, CURSOR_WIDTH, CURSOR_HEIGHT);
- gdk_color_white (gdk_colormap_get_system (), &bg);
- gdk_color_black (gdk_colormap_get_system (), &fg);
+ colormap = gdk_screen_get_system_colormap (screen);
+ gdk_color_white (colormap, &bg);
+ gdk_color_black (colormap, &fg);
drag_cursors[i].cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &fg, &bg, 0, 0);
g_return_if_fail (widget != NULL);
g_return_if_fail (context != NULL);
- selection_widget = gtk_drag_get_ipc_widget ();
+ selection_widget = gtk_drag_get_ipc_widget (gtk_widget_get_screen (widget));
gdk_drag_context_ref (context);
gtk_widget_ref (widget);
if (target != GDK_NONE)
{
- GtkWidget *selection_widget = gtk_drag_get_ipc_widget ();
+ GtkWidget *selection_widget = gtk_drag_get_ipc_widget (gdk_drawable_get_screen (context->source_window));
gdk_drag_context_ref (context);
dest_info->proxy_source = NULL;
}
- ipc_widget = gtk_drag_get_ipc_widget ();
+ ipc_widget = gtk_drag_get_ipc_widget (gtk_widget_get_screen (widget));
context = gdk_drag_begin (ipc_widget->window,
dest_info->context->targets);
tmp_list = tmp_list->prev;
}
- ipc_widget = gtk_drag_get_ipc_widget ();
+ ipc_widget = gtk_drag_get_ipc_widget (gtk_widget_get_screen (widget));
source_widgets = g_slist_prepend (source_widgets, ipc_widget);
context = gdk_drag_begin (ipc_widget->window, targets);
gtk_drag_get_event_actions (event, info->button, actions,
&suggested_action, &possible_actions);
- info->cursor = gtk_drag_get_cursor (suggested_action);
+ info->cursor = gtk_drag_get_cursor (gtk_widget_get_screen (widget), suggested_action);
/* Set cur_x, cur_y here so if the "drag_begin" signal shows
* the drag icon, it will be in the right place
}
else
{
- gint x, y;
- gdk_window_get_pointer (GDK_ROOT_PARENT (), &x, &y, NULL);
-
- info->cur_x = x;
- info->cur_y = y;
+ gdk_window_get_pointer (gtk_widget_get_root_window (widget),
+ &info->cur_x, &info->cur_y, NULL);
}
gtk_signal_emit_by_name (GTK_OBJECT (widget), "drag_begin",
gint width, height;
GdkPixmap *pixmap;
GdkPixmap *mask;
-
+ GdkScreen *screen;
+ GdkColormap *colormap;
+
g_return_if_fail (context != NULL);
g_return_if_fail (pixbuf != NULL || stock_id != NULL);
g_return_if_fail (pixbuf == NULL || stock_id == NULL);
-
- gtk_widget_push_colormap (gdk_rgb_get_colormap ());
+
+ screen = gdk_drawable_get_screen (context->source_window);
+ colormap = gdk_screen_get_rgb_colormap (screen);
+
+ gtk_widget_push_colormap (colormap);
window = gtk_window_new (GTK_WINDOW_POPUP);
+ gtk_window_set_screen (GTK_WINDOW (window), screen);
gtk_widget_pop_colormap ();
gtk_widget_set_events (window, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gdk_pixbuf_get_height (pixbuf));
gtk_widget_realize (window);
- gdk_pixbuf_render_pixmap_and_mask (pixbuf, &pixmap, &mask, 128);
+ gdk_pixbuf_render_pixmap_and_mask_for_colormap (pixbuf, colormap, &pixmap, &mask, 128);
gdk_window_set_back_pixmap (window->window, pixmap, FALSE);
gtk_widget_push_colormap (colormap);
window = gtk_window_new (GTK_WINDOW_POPUP);
+ gtk_window_set_screen (GTK_WINDOW (window), gdk_drawable_get_screen (context->source_window));
gtk_widget_set_events (window, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
}
else
{
- cursor = gtk_drag_get_cursor (event->dnd.context->action);
+ cursor = gtk_drag_get_cursor (gtk_widget_get_screen (widget),
+ event->dnd.context->action);
if (info->cursor != cursor)
{
gdk_pointer_grab (widget->window, FALSE,
tmp_list = tmp_list->next;
}
- gtk_selection_owner_set (info->ipc_widget, selection, time);
+ gtk_selection_owner_set_for_display (gtk_widget_get_display (info->widget),
+ info->ipc_widget,
+ selection,
+ time);
info->selections = g_list_prepend (info->selections,
GUINT_TO_POINTER (selection));
gtk_drag_source_release_selections (GtkDragSourceInfo *info,
guint32 time)
{
+ GdkDisplay *display = gtk_widget_get_display (info->widget);
GList *tmp_list = info->selections;
+
while (tmp_list)
{
GdkAtom selection = GDK_POINTER_TO_ATOM (tmp_list->data);
- if (gdk_selection_owner_get (selection) == info->ipc_widget->window)
- gtk_selection_owner_set (NULL, selection, time);
+ if (gdk_selection_owner_get_for_display (display, selection) == info->ipc_widget->window)
+ gtk_selection_owner_set_for_display (display, NULL, selection, time);
+
tmp_list = tmp_list->next;
}
{
GdkEvent send_event;
GtkWidget *source_widget = info->widget;
+ GdkDisplay *display = gtk_widget_get_display (source_widget);
- gdk_pointer_ungrab (time);
- gdk_keyboard_ungrab (time);
-
+ gdk_display_pointer_ungrab (display, time);
+ gdk_display_keyboard_ungrab (display, time);
gtk_grab_remove (info->ipc_widget);
gtk_signal_disconnect_by_func (GTK_OBJECT (info->ipc_widget),
*/
send_event.button.type = GDK_BUTTON_RELEASE;
- send_event.button.window = GDK_ROOT_PARENT ();
+ send_event.button.window = gtk_widget_get_root_window (source_widget);
send_event.button.send_event = TRUE;
send_event.button.time = time;
send_event.button.x = 0;
if (event->is_hint)
{
- gdk_window_get_pointer (GDK_ROOT_PARENT(), &x_root, &y_root, NULL);
+ GdkWindow *root_window = gtk_widget_get_root_window (widget);
+
+ gdk_window_get_pointer (root_window, &x_root, &y_root, NULL);
event->x_root = x_root;
event->y_root = y_root;
}
{
GtkDragSourceInfo *info = (GtkDragSourceInfo *)data;
GdkModifierType state;
+ GdkWindow *root_window;
if (event->type == GDK_KEY_PRESS)
{
* to query it here. We could use XGetModifierMapping, but
* that would be overkill.
*/
- gdk_window_get_pointer (GDK_ROOT_PARENT(), NULL, NULL, &state);
+ root_window = gtk_widget_get_root_window (widget);
+ gdk_window_get_pointer (root_window, NULL, NULL, &state);
event->state = state;
gtk_drag_update (info, info->cur_x, info->cur_y, (GdkEvent *)event);
get_text_area_size (entry, &attributes.x, &attributes.y, &attributes.width, &attributes.height);
- attributes.cursor = gdk_cursor_new (GDK_XTERM);
+ attributes.cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (widget), GDK_XTERM);
attributes_mask |= GDK_WA_CURSOR;
entry->text_area = gdk_window_new (widget->window, &attributes, attributes_mask);
gtk_im_context_set_client_window (entry->im_context, entry->text_area);
gtk_entry_adjust_scroll (entry);
+ gtk_entry_update_primary_selection (entry);
}
static void
gtk_entry_unrealize (GtkWidget *widget)
{
GtkEntry *entry = GTK_ENTRY (widget);
+ GtkClipboard *clipboard;
gtk_im_context_set_client_window (entry->im_context, entry->text_area);
+
+ clipboard = gtk_widget_get_clipboard (widget, GDK_SELECTION_PRIMARY);
+ if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (entry))
+ gtk_clipboard_clear (clipboard);
if (entry->text_area)
{
{
GdkCursor *cursor;
- cursor = gdk_cursor_new (GDK_XTERM);
+ cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (widget), GDK_XTERM);
gdk_window_set_cursor (entry->text_area, cursor);
gdk_cursor_unref (cursor);
entry->mouse_cursor_obscured = FALSE;
entry->need_im_reset = TRUE;
gtk_im_context_focus_in (entry->im_context);
- g_signal_connect (gdk_keymap_get_default (),
+ g_signal_connect (gdk_keymap_get_for_display (gtk_widget_get_display (widget)),
"direction_changed",
G_CALLBACK (gtk_entry_keymap_direction_changed), entry);
gtk_entry_check_cursor_blink (entry);
- g_signal_handlers_disconnect_by_func (gdk_keymap_get_default (),
+ g_signal_handlers_disconnect_by_func (gdk_keymap_get_for_display (gtk_widget_get_display (widget)),
(gpointer) gtk_entry_keymap_direction_changed,
entry);
GTK_WIDGET_CLASS (parent_class)->grab_focus (widget);
- g_object_get (G_OBJECT (gtk_settings_get_default ()),
+ g_object_get (G_OBJECT (gtk_widget_get_settings (widget)),
"gtk-entry-select-on-focus",
&select_on_focus,
NULL);
n_chars = g_utf8_strlen (new_text, new_text_length);
if (entry->text_max_length > 0 && n_chars + entry->text_length > entry->text_max_length)
{
- gdk_beep ();
+ gdk_display_beep (gtk_widget_get_display (GTK_WIDGET (entry)));
n_chars = entry->text_max_length - entry->text_length;
new_text_length = g_utf8_offset_to_pointer (new_text, n_chars) - new_text;
}
get_better_cursor_x (GtkEntry *entry,
gint offset)
{
+ GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (entry)));
GtkTextDirection keymap_direction =
- (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
+ (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_LTR) ?
GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
GtkTextDirection widget_direction = gtk_widget_get_direction (GTK_WIDGET (entry));
gboolean split_cursor;
if (gtk_editable_get_selection_bounds (editable, &start, &end))
{
gchar *str = gtk_entry_get_public_chars (entry, start, end);
- gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD), str, -1);
+ gtk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (entry),
+ GDK_SELECTION_CLIPBOARD),
+ str, -1);
g_free (str);
}
}
gtk_entry_draw_cursor (GtkEntry *entry,
CursorType type)
{
+ GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (entry)));
GtkTextDirection keymap_direction =
- (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
+ (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_LTR) ?
GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
GtkTextDirection widget_direction = gtk_widget_get_direction (GTK_WIDGET (entry));
strong = TRUE;
else
{
+ GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (entry)));
GtkTextDirection keymap_direction =
- (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
+ (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_LTR) ?
GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
strong = keymap_direction == gtk_widget_get_direction (GTK_WIDGET (entry));
GdkAtom selection)
{
g_object_ref (G_OBJECT (entry));
- gtk_clipboard_request_text (gtk_clipboard_get (selection),
+ gtk_clipboard_request_text (gtk_widget_get_clipboard (GTK_WIDGET (entry), selection),
paste_received, entry);
}
{ "COMPOUND_TEXT", 0, 0 }
};
- GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
+ GtkClipboard *clipboard;
gint start, end;
+
+ if (!GTK_WIDGET_REALIZED (entry))
+ return;
+
+ clipboard = gtk_widget_get_clipboard (GTK_WIDGET (entry), GDK_SELECTION_PRIMARY);
if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start, &end))
{
{
GtkEntry *entry = GTK_ENTRY (user_data);
GtkWidget *widget = GTK_WIDGET (entry);
+ GdkScreen *screen = gtk_widget_get_screen (widget);
GtkRequisition req;
g_return_if_fail (GTK_WIDGET_REALIZED (entry));
*x += widget->allocation.width / 2;
*y += widget->allocation.height;
- *x = CLAMP (*x, 0, MAX (0, gdk_screen_width () - req.width));
- *y = CLAMP (*y, 0, MAX (0, gdk_screen_height () - req.height));
+ *x = CLAMP (*x, 0, MAX (0, gdk_screen_get_width (screen) - req.width));
+ *y = CLAMP (*y, 0, MAX (0, gdk_screen_get_height (screen) - req.height));
}
info->time = gtk_get_current_event_time ();
}
- gtk_clipboard_request_contents (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD),
+ gtk_clipboard_request_contents (gtk_widget_get_clipboard (GTK_WIDGET (entry), GDK_SELECTION_CLIPBOARD),
gdk_atom_intern ("TARGETS", FALSE),
popup_targets_received,
info);
if (!filename)
{
- gdk_beep ();
+ gdk_display_beep (gtk_widget_get_display (widget));
gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "insert_text");
return FALSE;
}
GParamSpec *pspec);
static void gtk_font_selection_init (GtkFontSelection *fontsel);
static void gtk_font_selection_finalize (GObject *object);
+static void gtk_font_selection_hierarchy_changed (GtkWidget *widget,
+ GtkWidget *previous_toplevel);
/* These are the callbacks & related functions. */
static void gtk_font_selection_select_font (GtkTreeSelection *selection,
gtk_font_selection_class_init (GtkFontSelectionClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
font_selection_parent_class = gtk_type_class (GTK_TYPE_VBOX);
gobject_class->set_property = gtk_font_selection_set_property;
gobject_class->get_property = gtk_font_selection_get_property;
+
+ widget_class->hierarchy_changed = gtk_font_selection_hierarchy_changed;
g_object_class_install_property (gobject_class,
PROP_FONT_NAME,
g_list_free (focus_chain);
/* Insert the fonts. */
- gtk_font_selection_show_available_fonts (fontsel);
-
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->family_list)), "changed",
G_CALLBACK (gtk_font_selection_select_font), fontsel);
GTK_SIGNAL_FUNC (gtk_font_selection_scroll_on_map),
fontsel);
- gtk_font_selection_show_available_styles (fontsel);
-
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->face_list)), "changed",
G_CALLBACK (gtk_font_selection_select_style), fontsel);
- gtk_font_selection_show_available_sizes (fontsel, TRUE);
-
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->size_list)), "changed",
G_CALLBACK (gtk_font_selection_select_size), fontsel);
gtk_box_pack_start (GTK_BOX (text_box), fontsel->preview_entry,
TRUE, TRUE, 0);
- gtk_font_selection_update_preview (fontsel);
-
gtk_widget_pop_composite_child();
}
(* G_OBJECT_CLASS (font_selection_parent_class)->finalize) (object);
}
+static void
+fontsel_screen_changed (GtkFontSelection *fontsel)
+{
+ GdkScreen *old_screen = g_object_get_data (G_OBJECT (fontsel), "gtk-font-selection-screen");
+ GdkScreen *screen;
+
+ if (gtk_widget_has_screen (GTK_WIDGET (fontsel)))
+ screen = gtk_widget_get_screen (GTK_WIDGET (fontsel));
+ else
+ screen = NULL;
+
+ if (screen == old_screen)
+ return;
+
+ if (fontsel->font)
+ {
+ gdk_font_unref (fontsel->font);
+ fontsel->font = NULL;
+ }
+
+ if (old_screen)
+ g_object_unref (old_screen);
+
+ if (screen)
+ {
+ g_object_ref (screen);
+ g_object_set_data (G_OBJECT (fontsel), "gtk-font-selection-screen", screen);
+
+ gtk_font_selection_show_available_fonts (fontsel);
+ gtk_font_selection_show_available_sizes (fontsel, TRUE);
+ gtk_font_selection_show_available_styles (fontsel);
+ }
+ else
+ g_object_set_data (G_OBJECT (fontsel), "gtk-font-selection-screen", NULL);
+}
+
+static void
+gtk_font_selection_hierarchy_changed (GtkWidget *widget,
+ GtkWidget *previous_toplevel)
+{
+ GtkWidget *toplevel;
+
+ if (previous_toplevel)
+ g_signal_handlers_disconnect_by_func (previous_toplevel,
+ (gpointer) fontsel_screen_changed,
+ widget);
+
+ toplevel = gtk_widget_get_toplevel (widget);
+ if (GTK_WIDGET_TOPLEVEL (toplevel))
+ g_signal_connect_swapped (toplevel,
+ "notify::screen",
+ G_CALLBACK (fontsel_screen_changed),
+ widget);
+
+ fontsel_screen_changed (GTK_FONT_SELECTION (widget));
+}
+
static void
gtk_font_selection_preview_changed (GtkWidget *entry,
GtkFontSelection *fontsel)
if (!fontsel->font)
{
PangoFontDescription *font_desc = gtk_font_selection_get_font_description (fontsel);
- fontsel->font = gdk_font_from_description (font_desc);
+ fontsel->font = gdk_font_from_description_for_display (gtk_widget_get_display (GTK_WIDGET (fontsel)), font_desc);
pango_font_description_free (font_desc);
}
gchar buf[64];
c->gamma_dialog = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (c->gamma_dialog),
+ gtk_widget_get_screen (w));
gtk_window_set_title (GTK_WINDOW (c->gamma_dialog), _("Gamma"));
g_object_add_weak_pointer (G_OBJECT (c->gamma_dialog),
(gpointer *)&c->gamma_dialog);
static gint initialize = TRUE;
static GCache *gc_cache = NULL;
-static GHashTable *gc_drawable_ht = NULL;
static GMemChunk *key_mem_chunk = NULL;
g_cache_remove (gc_cache, gc);
}
+static void
+free_gc_drawable (gpointer data)
+{
+ GtkGCDrawable *drawable = data;
+ g_object_unref (G_OBJECT (drawable->drawable));
+ g_free (drawable);
+}
+
+static GHashTable*
+gtk_gc_get_drawable_ht (GdkScreen *screen)
+{
+ GHashTable *ht = g_object_get_data (G_OBJECT (screen), "gtk-gc-drawable-ht");
+ if (!ht)
+ {
+ ht = g_hash_table_new_full ((GHashFunc) gtk_gc_drawable_hash,
+ (GEqualFunc) gtk_gc_drawable_equal,
+ NULL, free_gc_drawable);
+ g_object_set_data_full (G_OBJECT (screen),
+ "gtk-gc-drawable-ht", ht,
+ (GDestroyNotify)g_hash_table_destroy);
+ }
+
+ return ht;
+}
static void
gtk_gc_init (void)
(GHashFunc) gtk_gc_key_hash,
(GHashFunc) gtk_gc_value_hash,
(GEqualFunc) gtk_gc_key_equal);
-
- gc_drawable_ht = g_hash_table_new ((GHashFunc) gtk_gc_drawable_hash,
- (GEqualFunc) gtk_gc_drawable_equal);
}
static GtkGCKey*
GtkGCKey *keyval;
GtkGCDrawable *drawable;
GdkGC *gc;
+ GHashTable *ht;
keyval = key;
-
- drawable = g_hash_table_lookup (gc_drawable_ht, &keyval->depth);
+ ht = gtk_gc_get_drawable_ht (keyval->colormap->screen);
+ drawable = g_hash_table_lookup (ht, &keyval->depth);
if (!drawable)
{
drawable = g_new (GtkGCDrawable, 1);
drawable->depth = keyval->depth;
- drawable->drawable = gdk_pixmap_new (NULL, 1, 1, drawable->depth);
-
- g_hash_table_insert (gc_drawable_ht, &drawable->depth, drawable);
+ drawable->drawable = gdk_pixmap_new (gdk_screen_get_root_window (keyval->colormap->screen),
+ 1, 1, drawable->depth);
+ g_hash_table_insert (ht, &drawable->depth, drawable);
}
gc = gdk_gc_new_with_values (drawable->drawable, &keyval->values, keyval->mask);
return TRUE;
}
-
static guint
gtk_gc_drawable_hash (GtkGCDrawable *d)
{
GDK_FOCUS_CHANGE_MASK |
GDK_STRUCTURE_MASK);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
- hb->float_window = gdk_window_new (NULL, &attributes, attributes_mask);
+ hb->float_window = gdk_window_new (gtk_widget_get_root_window (widget),
+ &attributes, attributes_mask);
gdk_window_set_user_data (hb->float_window, widget);
gdk_window_set_decorations (hb->float_window, 0);
gdk_window_set_type_hint (hb->float_window, GDK_WINDOW_TYPE_HINT_TOOLBAR);
hb->attach_allocation.height = height;
hb->in_drag = TRUE;
- fleur = gdk_cursor_new (GDK_FLEUR);
+ fleur = gdk_cursor_new_for_screen (gdk_drawable_get_screen (widget->window),
+ GDK_FLEUR);
if (gdk_pointer_grab (widget->window,
FALSE,
(GDK_BUTTON1_MOTION_MASK |
if (event->window != widget->window)
return FALSE;
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
+ GDK_CURRENT_TIME);
hb->in_drag = FALSE;
event_handled = TRUE;
}
*/
new_x = 0;
new_y = 0;
- gdk_window_get_pointer (NULL, &new_x, &new_y, NULL);
+ gdk_window_get_pointer (gtk_widget_get_root_window (widget),
+ &new_x, &new_y, NULL);
new_x += hb->float_allocation.x;
new_y += hb->float_allocation.y;
/* this extra move is neccessary if we use decorations, or our
* window manager insists on decorations.
*/
- gdk_flush ();
+ gdk_display_sync (gtk_widget_get_display (widget));
gdk_window_move (hb->float_window, new_x, new_y);
- gdk_flush ();
+ gdk_display_sync (gtk_widget_get_display (widget));
#endif /* 0 */
gtk_signal_emit (GTK_OBJECT (hb),
handle_box_signals[SIGNAL_CHILD_DETACHED],
static void
gtk_handle_box_reattach (GtkHandleBox *hb)
{
+ GtkWidget *widget = GTK_WIDGET (hb);
+
if (hb->child_detached)
{
hb->child_detached = FALSE;
if (GTK_WIDGET_REALIZED (hb))
{
gdk_window_hide (hb->float_window);
- gdk_window_reparent (hb->bin_window, GTK_WIDGET (hb)->window, 0, 0);
+ gdk_window_reparent (hb->bin_window, widget->window, 0, 0);
if (GTK_BIN (hb)->child)
gtk_signal_emit (GTK_OBJECT (hb),
}
if (hb->in_drag)
{
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (GTK_WIDGET (hb)),
+ GDK_CURRENT_TIME);
hb->in_drag = FALSE;
}
priv = hsv->priv;
- cursor = gdk_cursor_new (GDK_CROSSHAIR);
+ cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (GTK_WIDGET (hsv)),
+ GDK_CROSSHAIR);
gdk_pointer_grab (priv->window, FALSE,
(GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK
} else
g_assert_not_reached ();
- gdk_pointer_ungrab (event->time);
-
+ gdk_display_pointer_ungrab (gdk_drawable_get_display (event->window),
+ event->time);
return TRUE;
}
/* Create clipping mask */
- mask = gdk_pixmap_new (NULL, width, height, 1);
+ mask = gdk_pixmap_new (GTK_WIDGET (hsv)->window, width, height, 1);
+
gc = gdk_gc_new (mask);
color.pixel = 0;
/* Create clipping mask */
- mask = gdk_pixmap_new (NULL, width, height, 1);
+ mask = gdk_pixmap_new (GTK_WIDGET (hsv)->window, width, height, 1);
+
gc = gdk_gc_new (mask);
color.pixel = 0;
context_simple->compose_buffer[0] = 0;
if (n_compose > 1) /* Invalid sequence */
{
- gdk_beep();
+ gdk_display_beep (gdk_drawable_get_display (event->window));
return TRUE;
}
static guint
canonical_hex_keyval (GdkEventKey *event)
{
+ GdkKeymap *keymap = gdk_keymap_get_for_display (gdk_drawable_get_display (event->window));
guint keyval;
guint *keyvals = NULL;
gint n_vals = 0;
/* See if this key would have generated a hex keyval in
* any other state, and return that hex keyval if so
*/
- gdk_keymap_get_entries_for_keycode (NULL,
- event->hardware_keycode, NULL,
- &keyvals, &n_vals);
+ gdk_keymap_get_entries_for_keycode (keymap,
+ event->hardware_keycode,
+ NULL,
+ &keyvals, &n_vals);
keyval = 0;
i = 0;
#include <gdk/gdk.h>
#include "gtksignal.h"
#include "gtkinvisible.h"
+#include "gtkintl.h"
+
+enum {
+ PROP_0,
+ PROP_SCREEN,
+ LAST_ARG
+};
static void gtk_invisible_class_init (GtkInvisibleClass *klass);
static void gtk_invisible_init (GtkInvisible *invisible);
static void gtk_invisible_show (GtkWidget *widget);
static void gtk_invisible_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
+static void gtk_invisible_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gtk_invisible_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+
+static GObject *gtk_invisible_constructor (GType type,
+ guint n_construct_properties,
+ GObjectConstructParam *construct_params);
+
+GObjectClass *parent_class;
GtkType
gtk_invisible_get_type (void)
static void
gtk_invisible_class_init (GtkInvisibleClass *class)
{
+ GObjectClass *gobject_class;
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
widget_class = (GtkWidgetClass*) class;
object_class = (GtkObjectClass*) class;
+ gobject_class = (GObjectClass*) class;
+
+ parent_class = g_type_class_peek_parent (class);
widget_class->realize = gtk_invisible_realize;
widget_class->style_set = gtk_invisible_style_set;
widget_class->size_allocate = gtk_invisible_size_allocate;
object_class->destroy = gtk_invisible_destroy;
+ gobject_class->set_property = gtk_invisible_set_property;
+ gobject_class->get_property = gtk_invisible_get_property;
+ gobject_class->constructor = gtk_invisible_constructor;
+
+ g_object_class_install_property (gobject_class,
+ PROP_SCREEN,
+ g_param_spec_object ("screen",
+ _("Screen"),
+ _("The screen where this window will be displayed."),
+ GDK_TYPE_SCREEN,
+ G_PARAM_READWRITE));
}
static void
gtk_object_sink (GTK_OBJECT (invisible));
invisible->has_user_ref_count = TRUE;
+ invisible->screen = gdk_get_default_screen ();
colormap = _gtk_widget_peek_colormap ();
if (colormap)
}
}
+/**
+ * gtk_invisible_new_for_screen:
+ * @screen: a #GdkScreen which identifies on which
+ * the new #GtkInvisible will be created.
+ *
+ * Creates a new #GtkInvisible object for a specified screen
+ *
+ * Return value: a newly created #GtkInvisible object
+ **/
+GtkWidget*
+gtk_invisible_new_for_screen (GdkScreen *screen)
+{
+ g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+
+ return g_object_new (GTK_TYPE_INVISIBLE, "screen", screen, NULL);
+}
+
+/**
+ * gtk_invisible_new:
+ *
+ * Creates a new #GtkInvisible.
+ *
+ * Return value: a new #GtkInvisible.
+ **/
GtkWidget*
gtk_invisible_new (void)
{
- GtkWidget *result = GTK_WIDGET (gtk_type_new (GTK_TYPE_INVISIBLE));
- gtk_widget_realize (result);
+ return g_object_new (GTK_TYPE_INVISIBLE, NULL);
+}
- return result;
+/**
+ * gtk_invisible_set_screen:
+ * @invisible: a #GtkInvisible.
+ * @screen: a #GdkScreen.
+ *
+ * Sets the #GdkScreen where the #GtkInvisible object will be displayed.
+ **/
+void
+gtk_invisible_set_screen (GtkInvisible *invisible,
+ GdkScreen *screen)
+{
+ gboolean was_realized;
+
+ g_return_if_fail (GTK_IS_INVISIBLE (invisible));
+ g_return_if_fail (GDK_IS_SCREEN (screen));
+
+ if (screen == invisible->screen)
+ return;
+
+ was_realized = GTK_WIDGET_REALIZED (invisible);
+
+ if (was_realized)
+ gtk_widget_unrealize (GTK_WIDGET (invisible));
+ invisible->screen = screen;
+ if (was_realized)
+ gtk_widget_realize (GTK_WIDGET (invisible));
+}
+
+/**
+ * gtk_invisible_get_screen:
+ * @invisible: a #GtkInvisible.
+ *
+ * Returns the #GdkScreen object associated with @invisible
+ *
+ * Return value : the associated #GdkScreen.
+ **/
+GdkScreen *
+gtk_invisible_get_screen (GtkInvisible *invisible)
+{
+ g_return_val_if_fail (GTK_IS_INVISIBLE (invisible), NULL);
+
+ return invisible->screen;
}
static void
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_NOREDIR;
- widget->window = gdk_window_new (NULL, &attributes, attributes_mask);
+ widget->window = gdk_window_new (gtk_widget_get_root_window (widget),
+ &attributes, attributes_mask);
+
gdk_window_set_user_data (widget->window, widget);
widget->style = gtk_style_attach (widget->style, widget->window);
GtkAllocation *allocation)
{
widget->allocation = *allocation;
+}
+
+
+static void
+gtk_invisible_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkInvisible *invisible = GTK_INVISIBLE (object);
+
+ switch (prop_id)
+ {
+ case PROP_SCREEN:
+ gtk_invisible_set_screen (invisible, g_value_get_object (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
}
+
+static void
+gtk_invisible_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkInvisible *invisible = GTK_INVISIBLE (object);
+
+ switch (prop_id)
+ {
+ case PROP_SCREEN:
+ g_value_set_object (value, invisible->screen);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+/* We use a constructor here so that we can realize the invisible on
+ * the correct screen after the "screen" property has been set
+ */
+static GObject*
+gtk_invisible_constructor (GType type,
+ guint n_construct_properties,
+ GObjectConstructParam *construct_params)
+{
+ GObject *object;
+
+ object = (* G_OBJECT_CLASS (parent_class)->constructor) (type,
+ n_construct_properties,
+ construct_params);
+
+ gtk_widget_realize (GTK_WIDGET (object));
+
+ return object;
+}
+
#include <gtk/gtkwidget.h>
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
+G_BEGIN_DECLS
#define GTK_TYPE_INVISIBLE (gtk_invisible_get_type ())
#define GTK_INVISIBLE(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_INVISIBLE, GtkInvisible))
{
GtkWidget widget;
gboolean has_user_ref_count;
- gpointer gtk_reserved1; /* For future GdkScreen * */
+ GdkScreen *screen;
};
struct _GtkInvisibleClass
void (*_gtk_reserved4) (void);
};
-GtkType gtk_invisible_get_type (void) G_GNUC_CONST;
-GtkWidget* gtk_invisible_new (void);
+GtkType gtk_invisible_get_type (void) G_GNUC_CONST;
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+GtkWidget* gtk_invisible_new (void);
+GtkWidget* gtk_invisible_new_for_screen (GdkScreen *screen);
+void gtk_invisible_set_screen (GtkInvisible *invisible,
+ GdkScreen *screen);
+GdkScreen* gtk_invisible_get_screen (GtkInvisible *invisible);
+G_END_DECLS
#endif /* __GTK_INVISIBLE_H__ */
/* barf if there was nothing to activate */
g_warning ("Couldn't find a target for a mnemonic activation.");
- gdk_beep ();
+ gdk_display_beep (gtk_widget_get_display (widget));
return FALSE;
}
GtkWidget *old_toplevel)
{
GtkLabel *label = GTK_LABEL (widget);
+
+ /* in case the label has been reparented to another screen */
+ gtk_label_clear_layout (label);
gtk_label_setup_mnemonic (label, label->mnemonic_keyval);
}
pango_layout_set_width (label->layout, aux_info->width * PANGO_SCALE);
else
{
+ GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (label));
gint wrap_width;
pango_layout_set_width (label->layout, -1);
wrap_width = get_label_wrap_width (label);
width = MIN (width, wrap_width);
width = MIN (width,
- PANGO_SCALE * (gdk_screen_width () + 1) / 2);
+ PANGO_SCALE * (gdk_screen_get_width (screen) + 1) / 2);
pango_layout_set_width (label->layout, width);
pango_layout_get_extents (label->layout, NULL, &logical_rect);
GdkGC *gc;
keymap_direction =
- (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
+ (gdk_keymap_get_direction (gdk_keymap_get_for_display (gtk_widget_get_display (widget))) == PANGO_DIRECTION_LTR) ?
GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
widget_direction = gtk_widget_get_direction (widget);
attributes.window_type = GDK_WINDOW_TEMP;
attributes.wclass = GDK_INPUT_ONLY;
attributes.override_redirect = TRUE;
- attributes.cursor = gdk_cursor_new (GDK_XTERM);
+ attributes.cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (widget),
+ GDK_XTERM);
attributes.event_mask = gtk_widget_get_events (widget) |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
label->select_info->selection_anchor = anchor_index;
label->select_info->selection_end = end_index;
- clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
+ clipboard = gtk_widget_get_clipboard (GTK_WIDGET (label),
+ GDK_SELECTION_PRIMARY);
if (anchor_index != end_index)
{
gint *x,
gint *y)
{
+ GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (label)));
GtkTextDirection keymap_direction =
- (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
+ (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_LTR) ?
GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
GtkTextDirection widget_direction = gtk_widget_get_direction (GTK_WIDGET (label));
gboolean split_cursor;
strong = TRUE;
else
{
+ GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (label)));
GtkTextDirection keymap_direction =
- (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
+ (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_LTR) ?
GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
strong = keymap_direction == gtk_widget_get_direction (GTK_WIDGET (label));
start = len;
if (start != end)
- gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD),
+ gtk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (label),
+ GDK_SELECTION_CLIPBOARD),
label->text + start, end - start);
}
}
GtkLabel *label;
GtkWidget *widget;
GtkRequisition req;
+ GdkScreen *screen;
label = GTK_LABEL (user_data);
widget = GTK_WIDGET (label);
return;
g_return_if_fail (GTK_WIDGET_REALIZED (label));
-
+
+ screen = gtk_widget_get_screen (widget);
gdk_window_get_origin (widget->window, x, y);
gtk_widget_size_request (label->select_info->popup_menu, &req);
*x += widget->allocation.width / 2;
*y += widget->allocation.height;
- *x = CLAMP (*x, 0, MAX (0, gdk_screen_width () - req.width));
- *y = CLAMP (*y, 0, MAX (0, gdk_screen_height () - req.height));
+ *x = CLAMP (*x, 0, MAX (0, gdk_screen_get_width (screen) - req.width));
+ *y = CLAMP (*y, 0, MAX (0, gdk_screen_get_height (screen) - req.height));
}
&widget->style->base[GTK_STATE_NORMAL]);
}
+static gboolean
+list_has_grab (GtkList *list)
+{
+ return (GTK_WIDGET_HAS_GRAB (list) &&
+ gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (list))));
+
+}
+
static void
gtk_list_unmap (GtkWidget *widget)
{
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
+ if (list_has_grab (list))
{
gtk_list_end_drag_selection (list);
gtk_grab_add (widget);
list->drag_selection = TRUE;
}
- else if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
+ else if (list_has_grab (list))
gtk_list_end_drag_selection (list);
if (!GTK_WIDGET_HAS_FOCUS(item))
if (!list->children)
return;
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
+ if (list_has_grab (list))
gtk_list_end_drag_selection (list);
if (list->selection_mode == GTK_SELECTION_MULTIPLE && list->anchor >= 0)
if (!list->children)
return;
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
+ if (list_has_grab (list))
gtk_list_end_drag_selection (list);
if (list->selection_mode == GTK_SELECTION_MULTIPLE && list->anchor >= 0)
g_return_if_fail (GTK_IS_LIST (list));
- if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)) ||
+ if (list_has_grab (list) ||
list->selection_mode != GTK_SELECTION_MULTIPLE)
return;
g_return_if_fail (GTK_IS_LIST (list));
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
+ if (list_has_grab (list))
return;
container = GTK_CONTAINER (list);
g_return_if_fail (GTK_IS_LIST (list));
- if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)) ||
- list->anchor < 0)
+ if (list_has_grab (list) || list->anchor < 0)
return;
i = MIN (list->anchor, list->drag_pos);
container = GTK_CONTAINER (list);
- if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)) ||
- !container->focus_child)
+ if (list_has_grab (list) || !container->focus_child)
return;
switch (list->selection_mode)
g_return_if_fail (list != 0);
g_return_if_fail (GTK_IS_LIST (list));
- if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)) ||
+ if (list_has_grab (list) ||
list->selection_mode != GTK_SELECTION_MULTIPLE)
return;
g_return_if_fail (GTK_IS_LIST (list));
if (list->selection_mode != GTK_SELECTION_MULTIPLE ||
- (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)))
+ list_has_grab (list))
return;
if (list->anchor >= 0)
g_return_if_fail (list != 0);
g_return_if_fail (GTK_IS_LIST (list));
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
+ if (list_has_grab (list))
return;
if (!(adj =
{
g_return_if_fail (GTK_IS_LIST (list));
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
+ if (list_has_grab (list))
return;
if (list->selection_mode == GTK_SELECTION_MULTIPLE)
static GSList *key_snoopers = NULL;
-static GdkVisual *gtk_visual; /* The visual to be used in creating new
- * widgets.
- */
-static GdkColormap *gtk_colormap; /* The colormap to be used in creating new
- * widgets.
- */
-
guint gtk_debug_flags = 0; /* Global GTK debug flag */
#ifdef G_ENABLE_DEBUG
}
}
- /* Initialize the default visual and colormap to be
- * used in creating widgets. (We want to use the system
- * defaults so as to be nice to the colormap).
- */
- gtk_visual = gdk_visual_get_system ();
- gtk_colormap = gdk_colormap_get_system ();
-
gtk_type_init (0);
_gtk_accel_map_init ();
_gtk_rc_init ();
{
if (!gtk_init_check (argc, argv))
{
- g_warning ("cannot open display: %s", gdk_get_display ());
+ char *display_name_arg = gdk_get_display_arg_name ();
+ g_warning ("cannot open display: %s", display_name_arg ? display_name_arg : " ");
exit (1);
}
}
GdkWindow *grab_window;
GtkWidget *event_widget, *grab_widget;
gboolean owner_events;
+ GdkDisplay *display;
switch (event->type)
{
case GDK_MOTION_NOTIFY:
case GDK_PROXIMITY_IN:
case GDK_PROXIMITY_OUT:
- if (!gdk_pointer_grab_info_libgtk_only (gdk_get_default_display(), &grab_window, &owner_events) ||
+ display = gdk_drawable_get_display (event->proximity.window);
+ if (!gdk_pointer_grab_info_libgtk_only (display, &grab_window, &owner_events) ||
!owner_events)
return NULL;
break;
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
- if (!gdk_keyboard_grab_info_libgtk_only (gdk_get_default_display(), &grab_window, &owner_events) ||
+ display = gdk_drawable_get_display (event->key.window);
+ if (!gdk_keyboard_grab_info_libgtk_only (display, &grab_window, &owner_events) ||
!owner_events)
return NULL;
break;
return TRUE;
else
{
- gdk_pointer_ungrab (activate_time);
+ gdk_display_pointer_ungrab (gdk_drawable_get_display (window),
+ activate_time);
return FALSE;
}
}
GtkWidget *parent;
GdkEvent *current_event;
GtkMenuShell *menu_shell;
+ GtkMenuAttachData *attach_data;
g_return_if_fail (GTK_IS_MENU (menu));
menu_shell = GTK_MENU_SHELL (menu);
menu_shell->parent_menu_shell = parent_menu_shell;
+
+ if (!g_object_get_data (G_OBJECT (menu), "gtk-menu-explicit-screen"))
+ {
+ /* The screen was not set explicitly, if the menu is
+ * attached to a widget, try to get screen from its
+ * toplevel window else go with the default
+ */
+ attach_data = gtk_object_get_data (GTK_OBJECT (menu), attach_data_key);
+ if (attach_data)
+ {
+ if (!GTK_WIDGET_REALIZED (menu))
+ gtk_window_set_screen (GTK_WINDOW (menu->toplevel),
+ gtk_widget_get_screen (attach_data->attach_widget));
+ }
+ }
/* Find the last viewable ancestor, and make an X grab on it
*/
*/
if (menu_shell->have_xgrab)
{
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
- gdk_keyboard_ungrab (GDK_CURRENT_TIME);
+ GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (menu));
+
+ gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
+ gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
}
}
if (!menu->tearoff_window)
{
- menu->tearoff_window = g_object_connect (gtk_widget_new (GTK_TYPE_WINDOW,
- "type", GTK_WINDOW_TOPLEVEL,
- NULL),
- "signal::destroy", gtk_widget_destroyed, &menu->tearoff_window,
- NULL);
+ menu->tearoff_window = gtk_widget_new (GTK_TYPE_WINDOW,
+ "type", GTK_WINDOW_TOPLEVEL,
+ "screen", gtk_widget_get_screen (menu->toplevel),
+ "app_paintable", TRUE,
+ NULL);
+
gtk_window_set_type_hint (GTK_WINDOW (menu->tearoff_window),
GDK_WINDOW_TYPE_HINT_MENU);
gtk_window_set_mnemonic_modifier (GTK_WINDOW (menu->tearoff_window), 0);
- gtk_widget_set_app_paintable (menu->tearoff_window, TRUE);
- gtk_signal_connect (GTK_OBJECT (menu->tearoff_window),
- "event",
- GTK_SIGNAL_FUNC (gtk_menu_window_event),
- GTK_OBJECT (menu));
+ g_signal_connect (menu->tearoff_window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed), &menu->tearoff_window);
+ g_signal_connect (menu->tearoff_window, "event",
+ G_CALLBACK (gtk_menu_window_event), menu);
gtk_menu_update_title (menu);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_NOREDIR;
- window = gdk_window_new (NULL, &attributes, attributes_mask);
+ window = gdk_window_new (gtk_widget_get_root_window (GTK_WIDGET (menu)),
+ &attributes, attributes_mask);
gdk_window_set_user_data (window, menu);
gdk_window_show (window);
gchar *accel = NULL;
guint accel_key, accel_mods;
GdkModifierType consumed_modifiers;
+ GdkDisplay *display;
g_return_val_if_fail (GTK_IS_MENU (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
if (GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event))
return TRUE;
+
+ display = gtk_widget_get_display (widget);
- g_object_get (G_OBJECT (gtk_settings_get_default ()),
- "gtk-menu-bar-accel",
- &accel,
+ g_object_get (G_OBJECT (gtk_widget_get_settings (widget)),
+ "gtk-menu-bar-accel", &accel,
+ "gtk-can-change-accels", &can_change_accels,
NULL);
if (accel)
break;
}
- g_object_get (G_OBJECT (gtk_settings_get_default ()),
- "gtk-can-change-accels", &can_change_accels,
- NULL);
-
/* Figure out what modifiers went into determining the key symbol */
- gdk_keymap_translate_keyboard_state (gdk_keymap_get_default (),
+ gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (display),
event->hardware_keycode, event->state, event->group,
NULL, NULL, NULL, &consumed_modifiers);
* (basically, those items are accelerator-locked).
*/
/* g_print("item has no path or is locked, menu prefix: %s\n", menu->accel_path); */
- gdk_beep ();
+ gdk_display_beep (display);
}
else
{
* locked already
*/
/* g_print("failed to change\n"); */
- gdk_beep ();
+ gdk_display_beep (display);
}
}
}
GtkWidget *widget;
GtkRequisition requisition;
gint x, y;
- gint screen_width;
- gint screen_height;
gint scroll_offset;
gint menu_height;
gboolean push_in;
-
+ GdkScreen *screen;
+ GdkRectangle *monitor;
+ gint monitor_num;
+
g_return_if_fail (GTK_IS_MENU (menu));
widget = GTK_WIDGET (menu);
- screen_width = gdk_screen_width ();
- screen_height = gdk_screen_height ();
+ gdk_window_get_pointer (gtk_widget_get_root_window (widget),
+ &x, &y, NULL);
- gdk_window_get_pointer (NULL, &x, &y, NULL);
+ screen = gtk_widget_get_screen (widget);
+ monitor_num = gdk_screen_get_monitor_at_point (screen, x, y);
+ monitor = gdk_screen_get_monitor_geometry (screen, monitor_num);
/* We need the requisition to figure out the right place to
* popup the menu. In fact, we always need to ask here, since
(* menu->position_func) (menu, &x, &y, &push_in, menu->position_func_data);
else
{
- x = CLAMP (x - 2, 0, MAX (0, screen_width - requisition.width));
- y = CLAMP (y - 2, 0, MAX (0, screen_height - requisition.height));
+ x = CLAMP (x - 2, monitor->x, MAX (monitor->x, monitor->x + monitor->width - requisition.width));
+ y = CLAMP (y - 2, monitor->y, MAX (monitor->y, monitor->y + monitor->height - requisition.height));
}
scroll_offset = 0;
{
menu_height = GTK_WIDGET (menu)->requisition.height;
- if (y + menu_height > screen_height)
+ if (y + menu_height > monitor->y + monitor->height)
{
- scroll_offset -= y + menu_height - screen_height;
- y = screen_height - menu_height;
+ scroll_offset -= y + menu_height - (monitor->y + monitor->height);
+ y = (monitor->y + monitor->height) - menu_height;
}
- if (y < 0)
+ if (y < monitor->y)
{
scroll_offset -= y;
- y = 0;
+ y = monitor->y;
}
}
- if (y + requisition.height > screen_height)
- requisition.height = screen_height - y;
+ /* FIXME: should this be done in the various position_funcs ? */
+ x = CLAMP (x, monitor->x, MAX (monitor->x, monitor->x + monitor->width - requisition.width));
+
+ if (y + requisition.height > monitor->y + monitor->height)
+ requisition.height = (monitor->y + monitor->height) - y;
- if (y < 0)
+ if (y < monitor->y)
{
scroll_offset -= y;
requisition.height -= -y;
- y = 0;
+ y = monitor->y;
}
if (scroll_offset > 0)
gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
}
+/**
+ * gtk_menu_set_screen:
+ * @menu: a #GtkMenu.
+ * @screen: a #GtkScreen.
+ *
+ * Sets the #GtkScreen on which the GtkMenu will be displayed.
+ * This function can only be called before @menu is realized.
+ **/
+void
+gtk_menu_set_screen (GtkMenu *menu,
+ GdkScreen *screen)
+{
+ g_return_if_fail (GTK_IS_MENU (menu));
+ gtk_window_set_screen (GTK_WINDOW (menu->toplevel),
+ screen);
+ g_object_set_data (G_OBJECT (menu), "gtk-menu-explicit-screen", screen);
+}
GtkWidget *child,
gint position);
+void gtk_menu_set_screen (GtkMenu *menu,
+ GdkScreen *screen);
#ifndef GTK_DISABLE_DEPRECATED
#define gtk_menu_append(menu,child) gtk_menu_shell_append ((GtkMenuShell *)(menu),(child))
#define gtk_menu_prepend(menu,child) gtk_menu_shell_prepend ((GtkMenuShell *)(menu),(child))
GtkMenuItem *menu_item;
GtkWidget *widget;
GtkWidget *parent_menu_item;
+ GdkScreen *screen;
gint screen_width;
gint screen_height;
gint twidth, theight;
twidth = GTK_WIDGET (menu)->requisition.width;
theight = GTK_WIDGET (menu)->requisition.height;
- screen_width = gdk_screen_width ();
- screen_height = gdk_screen_height ();
+ screen = gtk_widget_get_screen (widget);
+ screen_width = gdk_screen_get_width (screen);
+ screen_height = gdk_screen_get_height (screen);
if (!gdk_window_get_origin (widget->window, &tx, &ty))
{
}
if (menu_shell->have_xgrab)
{
+ GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (menu_shell));
+
menu_shell->have_xgrab = FALSE;
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
- gdk_keyboard_ungrab (GDK_CURRENT_TIME);
+ gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
+ gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
}
}
}
/* flush the x-queue, so any grabs are removed and
* the menu is actually taken down
*/
- gdk_flush ();
+ gdk_display_sync (gtk_widget_get_display (menu_item));
}
gtk_widget_activate (menu_item);
if (current)
gtk_notebook_switch_page (notebook, current->data, -1);
else
- gdk_beep ();
+ gdk_display_beep (gtk_widget_get_display (GTK_WIDGET (notebook)));
}
static GtkDirectionType
if (new_page)
gtk_notebook_switch_focus_tab (notebook, new_page);
else
- gdk_beep ();
+ gdk_display_beep (gtk_widget_get_display (GTK_WIDGET (notebook)));
return TRUE;
}
gboolean claim,
guint32 time)
{
+ GtkWidget *widget = GTK_WIDGET (old_editable);
+ GdkDisplay *display = gtk_widget_get_display (widget);
+
g_return_if_fail (GTK_IS_OLD_EDITABLE (old_editable));
g_return_if_fail (GTK_WIDGET_REALIZED (old_editable));
if (claim)
{
- if (gtk_selection_owner_set (GTK_WIDGET (old_editable), GDK_SELECTION_PRIMARY, time))
+ if (gtk_selection_owner_set_for_display (display, widget,
+ GDK_SELECTION_PRIMARY, time))
old_editable->has_selection = TRUE;
}
else
{
- if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == GTK_WIDGET (old_editable)->window)
- gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY, time);
+ if (gdk_selection_owner_get_for_display (display, GDK_SELECTION_PRIMARY) == widget->window)
+ gtk_selection_owner_set_for_display (display,
+ NULL,
+ GDK_SELECTION_PRIMARY, time);
}
}
if (text)
{
- gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD), text, -1);
+ GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (old_editable),
+ GDK_SELECTION_CLIPBOARD);
+
+ gtk_clipboard_set_text (clipboard, text, -1);
g_free (text);
}
}
static void
gtk_old_editable_real_paste_clipboard (GtkOldEditable *old_editable)
{
+ GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (old_editable),
+ GDK_SELECTION_CLIPBOARD);
+
g_object_ref (G_OBJECT (old_editable));
- gtk_clipboard_request_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD),
- old_editable_text_received_cb, old_editable);
+ gtk_clipboard_request_text (clipboard, old_editable_text_received_cb, old_editable);
}
/**
children = children->next;
}
- screen_width = gdk_screen_width ();
+ screen_width = gdk_screen_get_width (gtk_widget_get_screen (widget));
if (menu_xpos < 0)
menu_xpos = 0;
attributes.y = paned->handle_pos.y;
attributes.width = paned->handle_pos.width;
attributes.height = paned->handle_pos.height;
- attributes.cursor = gdk_cursor_new (paned->cursor_type);
+ attributes.cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (widget),
+ paned->cursor_type);
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= (GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
paned->in_drag = FALSE;
paned->drag_pos = -1;
paned->position_set = TRUE;
- gdk_pointer_ungrab (event->time);
-
+ gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
+ event->time);
return TRUE;
}
widget_was_visible = GTK_WIDGET_VISIBLE (plug);
gdk_window_hide (widget->window);
- gdk_window_reparent (widget->window, GDK_ROOT_PARENT (), 0, 0);
+ gdk_window_reparent (widget->window,
+ gtk_widget_get_root_window (widget),
+ 0, 0);
GTK_PRIVATE_SET_FLAG (plug, GTK_IN_REPARENT);
gtk_widget_unparent (GTK_WIDGET (plug));
g_object_unref (socket);
}
+/**
+ * gtk_plug_construct:
+ * @display: the #GdkDisplay associated with @socket_id's #GtkSocket.
+ * @plug: a #GtkPlug.
+ * @socket_id: the XID of the socket's window.
+ *
+ * Finish the Initialization of @plug for a given #GtkSocket identified by
+ * @socket_id. This function will generally only be used by classes deriving from #GtkPlug.
+ **/
void
gtk_plug_construct (GtkPlug *plug,
GdkNativeWindow socket_id)
+{
+ gtk_plug_construct_for_display (gdk_get_default_display (), plug, socket_id);
+}
+
+/**
+ * gtk_plug_construct_for_display:
+ * @display: the #GdkDisplay associated with @socket_id's
+ * #GtkSocket.
+ * @plug: a #GtkPlug.
+ * @socket_id: the XID of the socket's window.
+ *
+ * Finish the Initialization of @plug for a given #GtkSocket identified by
+ * @socket_id which is currently displayed on @display.
+ * This function will generally only be used by classes deriving from #GtkPlug.
+ **/
+void
+gtk_plug_construct_for_display (GdkDisplay *display,
+ GtkPlug *plug,
+ GdkNativeWindow socket_id)
{
if (socket_id)
{
gpointer user_data = NULL;
- plug->socket_window = gdk_window_lookup (socket_id);
-
+ plug->socket_window = gdk_window_lookup_for_display (display, socket_id);
+
if (plug->socket_window)
gdk_window_get_user_data (plug->socket_window, &user_data);
else
- plug->socket_window = gdk_window_foreign_new (socket_id);
-
+ plug->socket_window = gdk_window_foreign_new_for_display (display, socket_id);
+
if (user_data)
{
if (GTK_IS_SOCKET (user_data))
}
}
+/**
+ * gtk_plug_new:
+ * @socket_id: the window ID of the socket, or 0.
+ *
+ * Creates a new plug widget inside the #GtkSocket identified
+ * by @socket_id. If @socket_id is 0, the plug is left "unplugged" and
+ * can later be plugged into a #GtkSocket by gtk_socket_add_id().
+ *
+ * Return value: the new #GtkPlug widget.
+ **/
GtkWidget*
gtk_plug_new (GdkNativeWindow socket_id)
+{
+ return gtk_plug_new_for_display (gdk_get_default_display (), socket_id);
+}
+
+/**
+ * gtk_plug_new_for_display:
+ * @display : the #GdkDisplay on which @socket_id is displayed
+ * @socket_id: the XID of the socket's window.
+ *
+ * Create a new plug widget inside the GtkSocket identified by socket_id.
+ *
+ * Return value: the new #GtkPlug widget.
+ */
+GtkWidget*
+gtk_plug_new_for_display (GdkDisplay *display,
+ GdkNativeWindow socket_id)
{
GtkPlug *plug;
plug = GTK_PLUG (gtk_type_new (GTK_TYPE_PLUG));
- gtk_plug_construct (plug, socket_id);
+ gtk_plug_construct_for_display (display, plug, socket_id);
return GTK_WIDGET (plug);
}
attributes.window_type = GDK_WINDOW_TOPLEVEL;
gdk_error_trap_push ();
- widget->window = gdk_window_new (plug->socket_window,
- &attributes, attributes_mask);
- gdk_flush ();
+ if (plug->socket_window)
+ widget->window = gdk_window_new (plug->socket_window,
+ &attributes, attributes_mask);
+ else /* If it's a passive plug, we use the root window */
+ widget->window = gdk_window_new (gtk_widget_get_root_window (widget),
+ &attributes, attributes_mask);
+
+ gdk_display_sync (gtk_widget_get_display (widget));
if (gdk_error_trap_pop ()) /* Uh-oh */
{
gdk_error_trap_push ();
gdk_window_destroy (widget->window);
gdk_flush ();
gdk_error_trap_pop ();
- widget->window = gdk_window_new (NULL, &attributes, attributes_mask);
+ widget->window = gdk_window_new (gtk_widget_get_root_window (widget),
+ &attributes, attributes_mask);
}
gdk_window_add_filter (widget->window, gtk_plug_filter_func, widget);
xembed_set_info (widget->window, 0);
}
else
- widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
+ widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
+ &attributes, attributes_mask);
gdk_window_set_user_data (widget->window, window);
XEvent xevent;
xevent.xfocus.type = FocusIn;
- xevent.xfocus.display = GDK_WINDOW_XDISPLAY (GTK_WIDGET(plug)->window);
+ xevent.xfocus.display = GDK_WINDOW_XDISPLAY (plug->socket_window);
xevent.xfocus.window = GDK_WINDOW_XWINDOW (plug->socket_window);
xevent.xfocus.mode = EMBEDDED_APP_WANTS_FOCUS;
xevent.xfocus.detail = FALSE; /* Don't force */
XSendEvent (GDK_DISPLAY (),
GDK_WINDOW_XWINDOW (plug->socket_window),
False, NoEventMask, &xevent);
- gdk_flush ();
+ gdk_display_sync (gdk_drawable_get_display (plug->socket_window));
gdk_error_trap_pop ();
#endif
gtk_window_set_focus (GTK_WINDOW (widget), NULL);
gdk_error_trap_push ();
- XSetInputFocus (GDK_DISPLAY (),
+ XSetInputFocus (GDK_WINDOW_XDISPLAY (plug->socket_window),
GDK_WINDOW_XWINDOW (plug->socket_window),
RevertToParent, event->time);
- gdk_flush ();
+ gdk_display_sync (gdk_drawable_get_display (plug->socket_window));
gdk_error_trap_pop ();
gtk_plug_forward_key_press (plug, event);
{
if (plug->socket_window)
{
+ GdkDisplay *display = gdk_drawable_get_display (plug->socket_window);
XEvent xevent;
xevent.xclient.window = GDK_WINDOW_XWINDOW (plug->socket_window);
xevent.xclient.type = ClientMessage;
- xevent.xclient.message_type = gdk_x11_get_xatom_by_name ("_XEMBED");
+ xevent.xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED");
xevent.xclient.format = 32;
xevent.xclient.data.l[0] = time;
xevent.xclient.data.l[1] = message;
xevent.xclient.data.l[4] = data2;
gdk_error_trap_push ();
- XSendEvent (GDK_DISPLAY (),
+ XSendEvent (GDK_WINDOW_XDISPLAY(plug->socket_window),
GDK_WINDOW_XWINDOW (plug->socket_window),
False, NoEventMask, &xevent);
- gdk_flush ();
+ gdk_display_sync (display);
gdk_error_trap_pop ();
}
}
if (!plug->modality_window)
{
plug->modality_window = gtk_window_new (GTK_WINDOW_POPUP);
+ gtk_window_set_screen (GTK_WINDOW (plug->modality_window),
+ gtk_widget_get_screen (GTK_WIDGET (plug)));
gtk_widget_realize (plug->modality_window);
gtk_window_group_add_window (plug->modality_group, GTK_WINDOW (plug->modality_window));
gtk_grab_add (plug->modality_window);
}
static void
-xembed_set_info (GdkWindow *gdk_window,
+xembed_set_info (GdkWindow *window,
unsigned long flags)
{
- Display *display = GDK_WINDOW_XDISPLAY (gdk_window);
- Window window = GDK_WINDOW_XWINDOW (gdk_window);
+ GdkDisplay *display = gdk_drawable_get_display (window);
unsigned long buffer[2];
-
- Atom xembed_info_atom = gdk_x11_get_xatom_by_name ("_XEMBED_INFO");
+
+ Atom xembed_info_atom = gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED_INFO");
buffer[1] = 0; /* Protocol version */
buffer[1] = flags;
- XChangeProperty (display, window,
+ XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
+ GDK_WINDOW_XWINDOW (window),
xembed_info_atom, xembed_info_atom, 32,
PropModeReplace,
(unsigned char *)buffer, 2);
static GdkFilterReturn
gtk_plug_filter_func (GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data)
{
+ GdkScreen *screen = gdk_drawable_get_screen (event->any.window);
+ GdkDisplay *display = gdk_screen_get_display (screen);
GtkPlug *plug = GTK_PLUG (data);
XEvent *xevent = (XEvent *)gdk_xevent;
switch (xevent->type)
{
case ClientMessage:
- if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name ("_XEMBED"))
+ if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED"))
{
handle_xembed_message (plug,
xevent->xclient.data.l[1],
return GDK_FILTER_REMOVE;
}
- else if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name ("WM_DELETE_WINDOW"))
+ else if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "WM_DELETE_WINDOW"))
{
/* We filter these out because we take being reparented back to the
* root window as the reliable end of the embedding protocol
* be invisible to the app.
*/
- if (xre->parent == GDK_ROOT_WINDOW())
+ if (xre->parent == GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen)))
{
GdkEvent event;
break;
}
- if (xre->parent != GDK_ROOT_WINDOW ())
+ if (xre->parent != GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen)))
{
/* Start of embedding protocol */
- plug->socket_window = gdk_window_lookup (xre->parent);
+ plug->socket_window = gdk_window_lookup_for_display (display, xre->parent);
if (plug->socket_window)
{
gpointer user_data = NULL;
}
else
{
- plug->socket_window = gdk_window_foreign_new (xre->parent);
+ plug->socket_window = gdk_window_foreign_new_for_display (display, xre->parent);
if (!plug->socket_window) /* Already gone */
break;
}
GtkType gtk_plug_get_type (void) G_GNUC_CONST;
-void gtk_plug_construct (GtkPlug *plug, GdkNativeWindow socket_id);
-GtkWidget* gtk_plug_new (GdkNativeWindow socket_id);
+#ifndef GDK_MULTIHEAD_SAFE
+void gtk_plug_construct (GtkPlug *plug,
+ GdkNativeWindow socket_id);
+GtkWidget* gtk_plug_new (GdkNativeWindow socket_id);
+#endif
+
+void gtk_plug_construct_for_display (GdkDisplay *display,
+ GtkPlug *plug,
+ GdkNativeWindow socket_id);
+GtkWidget* gtk_plug_new_for_display (GdkDisplay *display,
+ GdkNativeWindow socket_id);
+
GdkNativeWindow gtk_plug_get_id (GtkPlug *plug);
void _gtk_plug_add_to_socket (GtkPlug *plug,
GdkVisual*
gtk_preview_get_visual (void)
{
- return gdk_rgb_get_visual ();
+ return gdk_screen_get_rgb_visual (gdk_get_default_screen ());
}
GdkColormap*
gtk_preview_get_cmap (void)
{
- return gdk_rgb_get_colormap ();
+ return gdk_screen_get_rgb_colormap (gdk_get_default_screen ());
}
GtkPreviewInfo*
struct _GtkSelectionInfo
{
- GdkAtom selection;
- GtkWidget *widget; /* widget that owns selection */
- guint32 time; /* time used to acquire selection */
+ GdkAtom selection;
+ GtkWidget *widget; /* widget that owns selection */
+ guint32 time; /* time used to acquire selection */
+ GdkDisplay *display; /* needed in gtk_selection_remove_all */
};
struct _GtkIncrConversion
return FALSE;
}
-
-/*************************************************************
- * gtk_selection_owner_set:
- * Claim ownership of a selection.
- * arguments:
- * widget: new selection owner
- * selection: which selection
- * time: time (use GDK_CURRENT_TIME only if necessary)
+/**
+ * gtk_selection_owner_set_for_display:
+ * @display: the #Gdkdisplay where the selection is set
+ * @widget: new selection owner (a #GdkWidget), or %NULL.
+ * @selection: an interned atom representing the selection to claim.
+ * @time: timestamp with which to claim the selection
*
- * results:
- *************************************************************/
-
+ * Claim ownership of a given selection for a particular widget, or,
+ * if @widget is %NULL, release ownership of the selection.
+ *
+ * Return value: TRUE if the operation succeeded
+ */
gboolean
-gtk_selection_owner_set (GtkWidget *widget,
- GdkAtom selection,
- guint32 time)
+gtk_selection_owner_set_for_display (GdkDisplay *display,
+ GtkWidget *widget,
+ GdkAtom selection,
+ guint32 time)
{
GList *tmp_list;
GtkWidget *old_owner;
GtkSelectionInfo *selection_info = NULL;
GdkWindow *window;
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
g_return_val_if_fail (widget == NULL || GTK_WIDGET_REALIZED (widget), FALSE);
+ g_return_val_if_fail (widget == NULL || gtk_widget_get_display (widget) == display, FALSE);
if (widget == NULL)
window = NULL;
tmp_list = tmp_list->next;
}
- if (gdk_selection_owner_set (window, selection, time, TRUE))
+ if (gdk_selection_owner_set_for_display (display, window, selection, time, TRUE))
{
old_owner = NULL;
selection_info->selection = selection;
selection_info->widget = widget;
selection_info->time = time;
- current_selections = g_list_prepend (current_selections,
+ selection_info->display = display;
+ current_selections = g_list_prepend (current_selections,
selection_info);
}
else
old_owner = selection_info->widget;
selection_info->widget = widget;
selection_info->time = time;
+ selection_info->display = display;
}
}
/* If another widget in the application lost the selection,
return FALSE;
}
+/**
+ * gtk_selection_owner_set:
+ * @widget: a #GtkWidget, or %NULL.
+ * @selection: an interned atom representing the selection to claim
+ * @time: timestamp with which to claim the selection
+ *
+ * Claims ownership of a given selection for a particular widget,
+ * or, if @widget is %NULL, release ownership of the selection.
+ *
+ * Return value: %TRUE if the operation succeeded
+ **/
+gboolean
+gtk_selection_owner_set (GtkWidget *widget,
+ GdkAtom selection,
+ guint32 time)
+{
+ g_return_val_if_fail (widget == NULL || GTK_WIDGET_REALIZED (widget), FALSE);
+
+ return gtk_selection_owner_set_for_display (gdk_get_default_display(),
+ widget,
+ selection,
+ time);
+}
+
/*************************************************************
* gtk_selection_add_target
* Add specified target to list of supported targets
if (selection_info->widget == widget)
{
- gdk_selection_owner_set (NULL,
- selection_info->selection,
- GDK_CURRENT_TIME, FALSE);
- current_selections = g_list_remove_link (current_selections,
+ gdk_selection_owner_set_for_display (selection_info->display,
+ NULL,
+ selection_info->selection,
+ GDK_CURRENT_TIME, FALSE);
+ current_selections = g_list_remove_link (current_selections,
tmp_list);
g_list_free (tmp_list);
g_free (selection_info);
GtkRetrievalInfo *info;
GList *tmp_list;
GdkWindow *owner_window;
+ GdkDisplay *display;
g_return_val_if_fail (widget != NULL, FALSE);
/* Check if this process has current owner. If so, call handler
procedure directly to avoid deadlocks with INCR. */
-
- owner_window = gdk_selection_owner_get (selection);
+
+ display = gtk_widget_get_display (widget);
+ owner_window = gdk_selection_owner_get_for_display (display, selection);
if (owner_window != NULL)
{
selection_data.target = target;
selection_data.data = NULL;
selection_data.length = -1;
+ selection_data.display = display;
gdk_window_get_user_data (owner_window, (gpointer *)&owner_widget);
gint new_length;
tmp = g_strndup (str, len);
- if (gdk_utf8_to_compound_text (tmp, &encoding, &format, &text, &new_length))
+ if (gdk_utf8_to_compound_text_for_display (selection_data->display, tmp,
+ &encoding, &format, &text, &new_length))
{
gtk_selection_data_set (selection_data, encoding, format, text, new_length);
gdk_free_compound_text (text);
{
gchar **list;
gint i;
- gint count = gdk_text_property_to_utf8_list (selection_data->type,
- selection_data->format,
- selection_data->data,
- selection_data->length,
- &list);
+ gint count = gdk_text_property_to_utf8_list_for_display (selection_data->display,
+ selection_data->type,
+ selection_data->format,
+ selection_data->data,
+ selection_data->length,
+ &list);
if (count > 0)
result = list[0];
info->num_incrs = 0;
/* Create GdkWindow structure for the requestor */
- info->requestor = gdk_window_lookup (event->requestor);
+
+ info->requestor = gdk_window_lookup_for_display (gtk_widget_get_display (widget),
+ event->requestor);
if (!info->requestor)
- info->requestor = gdk_window_foreign_new (event->requestor);
+ info->requestor = gdk_window_foreign_new_for_display (gtk_widget_get_display (widget),
+ event->requestor);
/* Determine conversions we need to perform */
0, GTK_SELECTION_MAX_SIZE, FALSE,
&type, &format, &length, &mult_atoms))
{
- gdk_selection_send_notify (event->requestor, event->selection,
- event->target, GDK_NONE, event->time);
+ gdk_selection_send_notify_for_display (gtk_widget_get_display (widget),
+ event->requestor,
+ event->selection,
+ event->target,
+ GDK_NONE,
+ event->time);
g_free (mult_atoms);
g_free (info);
return TRUE;
data.target = info->conversions[i].target;
data.data = NULL;
data.length = -1;
+ data.display = gtk_widget_get_display (widget);
#ifdef DEBUG_SELECTION
g_message ("Selection %ld, target %ld (%s) requested by 0x%x (property = %ld)",
info->conversions[0].property == GDK_NONE)
{
/* Reject the entire conversion */
- gdk_selection_send_notify (event->requestor, event->selection,
- event->target, GDK_NONE, event->time);
+ gdk_selection_send_notify_for_display (gtk_widget_get_display (widget),
+ event->requestor,
+ event->selection,
+ event->target,
+ GDK_NONE,
+ event->time);
}
else
{
- gdk_selection_send_notify (event->requestor, event->selection,
- event->target, event->property, event->time);
+ gdk_selection_send_notify_for_display (gtk_widget_get_display (widget),
+ event->requestor,
+ event->selection,
+ event->target,
+ event->property,
+ event->time);
}
if (info->num_incrs == 0)
data.length = length;
data.data = buffer;
+ data.display = gtk_widget_get_display (info->widget);
gtk_signal_emit_by_name (GTK_OBJECT(info->widget),
"selection_received",
struct _GtkSelectionData
{
- GdkAtom selection;
- GdkAtom target;
- GdkAtom type;
- gint format;
- guchar *data;
- gint length;
+ GdkAtom selection;
+ GdkAtom target;
+ GdkAtom type;
+ gint format;
+ guchar *data;
+ gint length;
+ GdkDisplay *display;
};
struct _GtkTargetEntry {
/* Public interface */
-gboolean gtk_selection_owner_set (GtkWidget *widget,
- GdkAtom selection,
- guint32 time);
+gboolean gtk_selection_owner_set (GtkWidget *widget,
+ GdkAtom selection,
+ guint32 time);
+gboolean gtk_selection_owner_set_for_display (GdkDisplay *display,
+ GtkWidget *widget,
+ GdkAtom selection,
+ guint32 time);
+
void gtk_selection_add_target (GtkWidget *widget,
GdkAtom selection,
GdkAtom target,
static void gtk_settings_init (GtkSettings *settings);
static void gtk_settings_class_init (GtkSettingsClass *class);
static void gtk_settings_finalize (GObject *object);
-static GObject* gtk_settings_constructor (GType type,
- guint n_construct_properties,
- GObjectConstructParam *construct_properties);
static void gtk_settings_get_property (GObject *object,
guint property_id,
GValue *value,
/* --- variables --- */
static gpointer parent_class = NULL;
-static GtkSettings *the_singleton = NULL;
static GQuark quark_property_parser = 0;
static GSList *object_list = NULL;
static guint class_n_properties = 0;
parent_class = g_type_class_peek_parent (class);
- gobject_class->constructor = gtk_settings_constructor;
gobject_class->finalize = gtk_settings_finalize;
gobject_class->get_property = gtk_settings_get_property;
gobject_class->set_property = gtk_settings_set_property;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
-static GObject*
-gtk_settings_constructor (GType type,
- guint n_construct_properties,
- GObjectConstructParam *construct_properties)
+/**
+ * gtk_settings_get_for_screen:
+ * @screen : a #GdkScreen.
+ *
+ * Gets the #GtkSettings object for @screen, creating it if necessary.
+ *
+ * Return value: a #GtkSettings object.
+ */
+GtkSettings*
+gtk_settings_get_for_screen (GdkScreen *screen)
{
- GObject *object;
-
- /* currently we're a singleton, that might change with multiple display support though */
- if (!the_singleton)
+ GtkSettings *settings;
+
+ g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+
+ settings = g_object_get_data (G_OBJECT (screen), "gtk-settings");
+ if (!settings)
{
- object = G_OBJECT_CLASS (parent_class)->constructor (type,
- n_construct_properties,
- construct_properties);
- the_singleton = GTK_SETTINGS (g_object_ref (object));
+ settings = g_object_new (GTK_TYPE_SETTINGS, NULL);
+ settings->screen = screen;
+ g_object_set_data (G_OBJECT (screen), "gtk-settings", settings);
+ gtk_rc_reparse_all_for_settings (settings, TRUE);
}
- else
- object = g_object_ref (G_OBJECT (the_singleton));
-
- return object;
+
+ return settings;
}
+/**
+ * gtk_settings_get_default:
+ *
+ * Gets the #GtkSettings object for the default GDK screen, creating
+ * it if necessary. See gtk_settings_get_for_screen().
+ *
+ * Return value: a #GtkSettings object
+ **/
GtkSettings*
gtk_settings_get_default (void)
{
- if (!the_singleton)
- g_object_new (GTK_TYPE_SETTINGS, NULL);
-
- return the_singleton; /* we don't add a reference count here, we'd be settings_ref_global() if we did */
+ return gtk_settings_get_for_screen (gdk_get_default_screen ());
}
static void
g_value_type_transformable (G_TYPE_STRING, G_VALUE_TYPE (value)) ||
g_value_type_transformable (GDK_TYPE_COLOR, G_VALUE_TYPE (value)))
{
- if (gdk_setting_get (pspec->name, value))
+ if (gdk_screen_get_setting (settings->screen, pspec->name, value))
g_param_value_validate (pspec, value);
else
g_value_copy (settings->property_values + property_id - 1, value);
g_value_init (&val, G_TYPE_STRING);
- if (!gdk_setting_get (pspec->name, &val))
+ if (!gdk_screen_get_setting (settings->screen, pspec->name, &val))
{
g_value_copy (settings->property_values + property_id - 1, value);
}
gtk_settings_notify (GObject *object,
GParamSpec *pspec)
{
+ GtkSettings *settings = GTK_SETTINGS (object);
guint property_id = pspec->param_id;
gint double_click_time;
-
-#if 1
- GValue tmp_value = { 0, };
- gchar *contents;
- g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
- g_object_get_property (object, pspec->name, &tmp_value);
- contents = g_strdup_value_contents (&tmp_value);
+
+ if (settings->screen == NULL) /* initialization */
+ return;
switch (property_id)
{
gdk_set_double_click_time (double_click_time);
break;
}
-
- g_free (contents);
- g_value_unset (&tmp_value);
-#endif
}
gboolean
void
_gtk_settings_handle_event (GdkEventSetting *event)
{
- GtkSettings *settings = gtk_settings_get_default ();
+ GtkSettings *settings = gtk_settings_get_for_screen (gdk_drawable_get_screen (event->window));
if (g_object_class_find_property (G_OBJECT_GET_CLASS (settings), event->name))
g_object_notify (G_OBJECT (settings), event->name);
GValue *property_values;
GtkRcContext *rc_context;
+ GdkScreen *screen;
};
struct _GtkSettingsClass
{
/* --- functions --- */
GType gtk_settings_get_type (void);
+#ifndef GDK_MULTIHEAD_SAFE
GtkSettings* gtk_settings_get_default (void);
+#endif
+GtkSettings* gtk_settings_get_for_screen (GdkScreen *screen);
+
void gtk_settings_install_property (GParamSpec *pspec);
void gtk_settings_install_property_parser (GParamSpec *pspec,
GtkRcPropertyParser parser);
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
- XGetWindowAttributes (GDK_DISPLAY (),
+ XGetWindowAttributes (GDK_WINDOW_XDISPLAY (widget->window),
GDK_WINDOW_XWINDOW (widget->window),
&xattrs);
- XSelectInput (GDK_DISPLAY (),
- GDK_WINDOW_XWINDOW(widget->window),
+ XSelectInput (GDK_WINDOW_XDISPLAY (widget->window),
+ GDK_WINDOW_XWINDOW (widget->window),
xattrs.your_event_mask |
SubstructureNotifyMask | SubstructureRedirectMask);
* our window is passed to another application, SubstructureRedirectMask
* will be set by the time the other app creates its window.
*/
- gdk_flush();
+ gdk_display_sync (gtk_widget_get_display (widget));
}
static void
gdk_error_trap_push ();
- if (XGetWMNormalHints (GDK_DISPLAY(),
+ if (XGetWMNormalHints (GDK_WINDOW_XDISPLAY (socket->plug_window),
GDK_WINDOW_XWINDOW (socket->plug_window),
&hints, &supplied))
{
socket->need_map = FALSE;
}
- gdk_flush ();
+ gdk_display_sync (gtk_widget_get_display (widget));
gdk_error_trap_pop ();
}
}
GdkEvent *gdk_event = gtk_get_current_event ();
GtkSocket *socket = g_object_get_data (G_OBJECT (accel_group), "gtk-socket");
+ GdkScreen *screen = gdk_drawable_get_screen (socket->plug_window);
if (gdk_event && gdk_event->type == GDK_KEY_PRESS && socket->plug_window)
{
xevent.xkey.type = KeyPress;
xevent.xkey.window = GDK_WINDOW_XWINDOW (socket->plug_window);
- xevent.xkey.root = GDK_ROOT_WINDOW ();
+ xevent.xkey.root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen));
xevent.xkey.subwindow = None;
xevent.xkey.time = gdk_event->key.time;
xevent.xkey.x = 0;
xevent.xkey.same_screen = True;
gdk_error_trap_push ();
- XSendEvent (GDK_DISPLAY (),
+ XSendEvent (GDK_WINDOW_XDISPLAY (socket->plug_window),
GDK_WINDOW_XWINDOW (socket->plug_window),
False, KeyPressMask, &xevent);
- gdk_flush ();
+ gdk_display_sync (gdk_screen_get_display (screen));
gdk_error_trap_pop ();
}
if (GTK_WIDGET_HAS_FOCUS (socket) && socket->plug_window && !socket->plug_widget)
{
+ GdkScreen *screen = gdk_drawable_get_screen (socket->plug_window);
XEvent xevent;
xevent.xkey.type = KeyPress;
- xevent.xkey.display = GDK_WINDOW_XDISPLAY (event->window);
xevent.xkey.window = GDK_WINDOW_XWINDOW (socket->plug_window);
- xevent.xkey.root = GDK_ROOT_WINDOW ();
+ xevent.xkey.root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen));
xevent.xkey.time = event->time;
/* FIXME, the following might cause problems for non-GTK apps */
xevent.xkey.x = 0;
xevent.xkey.same_screen = TRUE; /* FIXME ? */
gdk_error_trap_push ();
- XSendEvent (GDK_DISPLAY (),
+ XSendEvent (GDK_WINDOW_XDISPLAY (socket->plug_window),
GDK_WINDOW_XWINDOW (socket->plug_window),
False, NoEventMask, &xevent);
- gdk_flush ();
+ gdk_display_sync (gtk_widget_get_display (widget));
gdk_error_trap_pop ();
return TRUE;
if (toplevel && GTK_IS_WINDOW (toplevel))
{
- XSetInputFocus (GDK_DISPLAY (),
+ XSetInputFocus (GDK_WINDOW_XDISPLAY (toplevel->window),
GDK_WINDOW_XWINDOW (toplevel->window),
RevertToParent, CurrentTime); /* FIXME? */
}
{
#if 0
gdk_error_trap_push ();
- XSetInputFocus (GDK_DISPLAY (),
+ XSetInputFocus (GDK_WINDOW_XDISPLAY (socket->plug_window),
GDK_WINDOW_XWINDOW (socket->plug_window),
RevertToParent, GDK_CURRENT_TIME);
- gdk_flush ();
+ gdk_display_sync (gdk_drawable_get_display (socket->plug_window));
gdk_error_trap_pop ();
#endif
}
#if 0
if (!socket->focus_in && socket->plug_window)
{
+ GdkScreen *screen = gdk_drawable_get_screen (socket->plug_window);
+ Display *xdisplay = GDK_SCREEN_XDISPLAY (screen);
XEvent xevent;
gtk_socket_claim_focus (socket);
xevent.xkey.type = KeyPress;
- xevent.xkey.display = GDK_DISPLAY ();
xevent.xkey.window = GDK_WINDOW_XWINDOW (socket->plug_window);
- xevent.xkey.root = GDK_ROOT_WINDOW (); /* FIXME */
- xevent.xkey.time = GDK_CURRENT_TIME; /* FIXME */
+ xevent.xkey.root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (socket->plug_window));
+ xevent.xkey.time = GDK_CURRENT_TIME;
/* FIXME, the following might cause big problems for
* non-GTK apps */
xevent.xkey.x = 0;
switch (direction)
{
case GTK_DIR_UP:
- xevent.xkey.keycode = XKeysymToKeycode(GDK_DISPLAY(), GDK_Up);
+ xevent.xkey.keycode = XKeysymToKeycode(xdisplay, GDK_Up);
break;
case GTK_DIR_DOWN:
- xevent.xkey.keycode = XKeysymToKeycode(GDK_DISPLAY(), GDK_Down);
+ xevent.xkey.keycode = XKeysymToKeycode(xdisplay, GDK_Down);
break;
case GTK_DIR_LEFT:
- xevent.xkey.keycode = XKeysymToKeycode(GDK_DISPLAY(), GDK_Left);
+ xevent.xkey.keycode = XKeysymToKeycode(xdisplay, GDK_Left);
break;
case GTK_DIR_RIGHT:
- xevent.xkey.keycode = XKeysymToKeycode(GDK_DISPLAY(), GDK_Right);
+ xevent.xkey.keycode = XKeysymToKeycode(xdisplay, GDK_Right);
break;
case GTK_DIR_TAB_FORWARD:
- xevent.xkey.keycode = XKeysymToKeycode(GDK_DISPLAY(), GDK_Tab);
+ xevent.xkey.keycode = XKeysymToKeycode(xdisplay, GDK_Tab);
break;
case GTK_DIR_TAB_BACKWARD:
- xevent.xkey.keycode = XKeysymToKeycode(GDK_DISPLAY(), GDK_Tab);
+ xevent.xkey.keycode = XKeysymToKeycode(xdisplay, GDK_Tab);
xevent.xkey.state = ShiftMask;
break;
}
gdk_error_trap_push ();
- XSendEvent (GDK_DISPLAY (),
+ XSendEvent (GDK_WINDOW_XDISPLAY (socket->plug_window),
GDK_WINDOW_XWINDOW (socket->plug_window),
False, NoEventMask, &xevent);
- gdk_flush();
+ gdk_display_sync (gdk_drawable_get_display (socket->plug_window));
gdk_error_trap_pop ();
return TRUE;
g_return_if_fail (socket->plug_window != NULL);
event.xconfigure.type = ConfigureNotify;
- event.xconfigure.display = GDK_DISPLAY ();
event.xconfigure.event = GDK_WINDOW_XWINDOW (socket->plug_window);
event.xconfigure.window = GDK_WINDOW_XWINDOW (socket->plug_window);
event.xconfigure.override_redirect = False;
gdk_error_trap_push ();
- XSendEvent (GDK_DISPLAY (),
+ XSendEvent (GDK_WINDOW_XDISPLAY (socket->plug_window),
GDK_WINDOW_XWINDOW (socket->plug_window),
False, NoEventMask, &event);
- gdk_flush ();
+ gdk_display_sync (gtk_widget_get_display (GTK_WIDGET (socket)));
gdk_error_trap_pop ();
}
{
GtkWidget *widget = GTK_WIDGET (socket);
+ GdkDisplay *display = gtk_widget_get_display (widget);
gpointer user_data = NULL;
- socket->plug_window = gdk_window_lookup (xid);
+ socket->plug_window = gdk_window_lookup_for_display (display, xid);
if (socket->plug_window)
{
if (!socket->plug_window)
{
- socket->plug_window = gdk_window_foreign_new (xid);
+ socket->plug_window = gdk_window_foreign_new_for_display (display, xid);
if (!socket->plug_window) /* was deleted before we could get it */
{
gdk_error_trap_pop ();
}
}
- XSelectInput (GDK_DISPLAY (),
- GDK_WINDOW_XWINDOW(socket->plug_window),
+ XSelectInput (GDK_DISPLAY_XDISPLAY (display),
+ GDK_WINDOW_XWINDOW (socket->plug_window),
StructureNotifyMask | PropertyChangeMask);
if (gdk_error_trap_pop ())
socket->need_map = socket->is_mapped;
- if (gdk_drag_get_protocol (xid, &protocol))
+ if (gdk_drag_get_protocol_for_display (display, xid, &protocol))
gtk_drag_dest_set_proxy (GTK_WIDGET (socket), socket->plug_window,
protocol, TRUE);
-
- gdk_flush ();
+
+ gdk_display_sync (display);
gdk_error_trap_pop ();
gdk_window_add_filter (socket->plug_window,
if (socket->plug_window)
{
+ GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (socket));
XEvent xevent;
xevent.xclient.window = GDK_WINDOW_XWINDOW (socket->plug_window);
xevent.xclient.type = ClientMessage;
- xevent.xclient.message_type = gdk_x11_get_xatom_by_name ("_XEMBED");
+ xevent.xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED");
xevent.xclient.format = 32;
xevent.xclient.data.l[0] = time;
xevent.xclient.data.l[1] = message;
xevent.xclient.data.l[4] = data2;
gdk_error_trap_push ();
- XSendEvent (GDK_DISPLAY (),
+ XSendEvent (GDK_DISPLAY_XDISPLAY (display),
GDK_WINDOW_XWINDOW (socket->plug_window),
False, NoEventMask, &xevent);
- gdk_flush ();
+ gdk_display_sync (display);
gdk_error_trap_pop ();
}
}
static gboolean
-xembed_get_info (GdkWindow *gdk_window,
+xembed_get_info (GdkWindow *window,
unsigned long *version,
unsigned long *flags)
{
- Display *display = GDK_WINDOW_XDISPLAY (gdk_window);
- Window window = GDK_WINDOW_XWINDOW (gdk_window);
- Atom xembed_info_atom = gdk_x11_get_xatom_by_name ("_XEMBED_INFO");
+ GdkDisplay *display = gdk_drawable_get_display (window);
+ Atom xembed_info_atom = gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED_INFO");
Atom type;
int format;
unsigned long nitems, bytes_after;
int status;
gdk_error_trap_push();
- status = XGetWindowProperty (display, window,
+ status = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
+ GDK_WINDOW_XWINDOW (window),
xembed_info_atom,
0, 2, False,
xembed_info_atom, &type, &format,
break;
default:
- GTK_NOTE(PLUGSOCKET,
- g_message ("GtkSocket: Ignoring unknown _XEMBED message of type %ld", message));
+ GTK_NOTE (PLUGSOCKET,
+ g_message ("GtkSocket: Ignoring unknown _XEMBED message of type %ld", message));
break;
}
}
{
GtkSocket *socket;
GtkWidget *widget;
+ GdkDisplay *display;
XEvent *xevent;
GdkFilterReturn return_val;
socket = GTK_SOCKET (data);
widget = GTK_WIDGET (socket);
xevent = (XEvent *)gdk_xevent;
+ display = gdk_drawable_get_display (event->any.window);
return_val = GDK_FILTER_CONTINUE;
switch (xevent->type)
{
case ClientMessage:
- if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name ("_XEMBED"))
+ if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED"))
{
handle_xembed_message (socket,
xevent->xclient.data.l[1],
if (toplevel && GTK_IS_WINDOW (topelevel))
{
- XSetInputFocus (GDK_DISPLAY (),
+ XSetInputFocus (GDK_WINDOW_XDISPLAY (toplevel->window),
GDK_WINDOW_XWINDOW (toplevel->window),
RevertToParent, CurrentTime); /* FIXME? */
}
{
GdkDragProtocol protocol;
- if ((xevent->xproperty.atom == gdk_x11_get_xatom_by_name ("XdndAware")) ||
- (xevent->xproperty.atom == gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_RECEIVER_INFO")))
+ if ((xevent->xproperty.atom == gdk_x11_get_xatom_by_name_for_display (display, "XdndAware")) ||
+ (xevent->xproperty.atom == gdk_x11_get_xatom_by_name_for_display (display, "_MOTIF_DRAG_RECEIVER_INFO")))
{
gdk_error_trap_push ();
- if (gdk_drag_get_protocol (xevent->xproperty.window, &protocol))
+ if (gdk_drag_get_protocol_for_display (display,
+ xevent->xproperty.window,
+ &protocol))
gtk_drag_dest_set_proxy (GTK_WIDGET (socket),
socket->plug_window,
protocol, TRUE);
- gdk_flush ();
+
+ gdk_display_sync (display);
gdk_error_trap_pop ();
}
- else if (xevent->xproperty.atom == gdk_x11_get_xatom_by_name ("_XEMBED_INFO"))
+ else if (xevent->xproperty.atom == gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED_INFO"))
{
unsigned long flags;
GValue value;
} PropertyValue;
-
/* --- prototypes --- */
static void gtk_style_init (GtkStyle *style);
static void gtk_style_class_init (GtkStyleClass *klass);
static struct {
char *bits;
- GdkBitmap *bmap;
+ GList *bmap_list; /* list of GdkBitmap */
} indicator_parts[] = {
{ check_aa_bits, NULL },
{ check_base_bits, NULL },
if (!new_style)
{
new_style = gtk_style_duplicate (style);
+ if (style->colormap->screen != colormap->screen &&
+ new_style->private_font)
+ {
+ gdk_font_unref (new_style->private_font);
+ new_style->private_font = NULL;
+ }
gtk_style_realize (new_style, colormap);
}
gdk_window_get_size (window, NULL, height);
}
+static GdkBitmap *
+get_indicator_for_screen (GdkDrawable *drawable,
+ IndicatorPart part)
+
+{
+ GdkScreen *screen = gdk_drawable_get_screen (drawable);
+ GdkBitmap *bitmap;
+ GList *tmp_list;
+
+ tmp_list = indicator_parts[part].bmap_list;
+ while (tmp_list)
+ {
+ bitmap = tmp_list->data;
+
+ if (gdk_drawable_get_screen (bitmap) == screen)
+ return bitmap;
+
+ tmp_list = tmp_list->next;
+ }
+
+ bitmap = gdk_bitmap_create_from_data (drawable,
+ indicator_parts[part].bits,
+ INDICATOR_PART_SIZE, INDICATOR_PART_SIZE);
+ indicator_parts[part].bmap_list = g_list_prepend (indicator_parts[part].bmap_list, bitmap);
+
+ return bitmap;
+}
+
static void
draw_part (GdkDrawable *drawable,
GdkGC *gc,
if (area)
gdk_gc_set_clip_rectangle (gc, area);
- if (!indicator_parts[part].bmap)
- indicator_parts[part].bmap = gdk_bitmap_create_from_data (drawable,
- indicator_parts[part].bits,
- INDICATOR_PART_SIZE, INDICATOR_PART_SIZE);
-
gdk_gc_set_ts_origin (gc, x, y);
- gdk_gc_set_stipple (gc, indicator_parts[part].bmap);
+ gdk_gc_set_stipple (gc, get_indicator_for_screen (drawable, part));
gdk_gc_set_fill (gc, GDK_STIPPLED);
gdk_draw_rectangle (drawable, gc, TRUE, x, y, INDICATOR_PART_SIZE, INDICATOR_PART_SIZE);
gint y,
const gchar *string)
{
+ GdkDisplay *display;
+
g_return_if_fail (GTK_IS_STYLE (style));
g_return_if_fail (window != NULL);
+ display = gdk_drawable_get_display (window);
+
if (area)
{
gdk_gc_set_clip_rectangle (style->white_gc, area);
}
if (state_type == GTK_STATE_INSENSITIVE)
- gdk_draw_string (window, gtk_style_get_font (style), style->white_gc, x + 1, y + 1, string);
+ gdk_draw_string (window,
+ gtk_style_get_font_for_display (display, style),
+ style->white_gc, x + 1, y + 1, string);
- gdk_draw_string (window, gtk_style_get_font (style), style->fg_gc[state_type], x, y, string);
+ gdk_draw_string (window,
+ gtk_style_get_font_for_display (display, style),
+ style->fg_gc[state_type], x, y, string);
if (area)
{
}
static PangoLayout*
-get_insensitive_layout (PangoLayout *layout)
+get_insensitive_layout (GdkDrawable *drawable,
+ PangoLayout *layout)
{
GSList *embossed_ranges = NULL;
GSList *stippled_ranges = NULL;
0x02, 0x01
};
- stipple = gdk_bitmap_create_from_data (NULL,
+ stipple = gdk_bitmap_create_from_data (drawable,
gray50_bits, gray50_width,
gray50_height);
}
{
PangoLayout *ins;
- ins = get_insensitive_layout (layout);
+ ins = get_insensitive_layout (window, layout);
gdk_draw_layout (window, gc, x, y, ins);
}
/**
- * gtk_style_get_font:
+ * gtk_style_get_font_for_display:
+ * @display : a #GdkDisplay
* @style: a #GtkStyle
*
* Gets the #GdkFont to use for the given style. This is
- * meant only as a replacement for direct access to @style->font
+ * meant only as a replacement for direct access to style->font
* and should not be used in new code. New code should
- * use @style->font_desc instead.
+ * use style->font_desc instead.
*
* Return value: the #GdkFont for the style. This font is owned
* by the style; if you want to keep around a copy, you must
* call gdk_font_ref().
**/
GdkFont *
-gtk_style_get_font (GtkStyle *style)
+gtk_style_get_font_for_display (GdkDisplay *display,
+ GtkStyle *style)
{
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
if (style->private_font && style->private_font_desc)
{
if (style->font_desc)
{
- style->private_font = gdk_font_from_description (style->font_desc);
+ /* no colormap, no screen */
+ style->private_font = gdk_font_from_description_for_display (display, style->font_desc);
style->private_font_desc = pango_font_description_copy (style->font_desc);
}
if (!style->private_font)
- style->private_font = gdk_font_load ("fixed");
-
+ style->private_font = gdk_font_load_for_display (display, "fixed");
+
if (!style->private_font)
g_error ("Unable to load \"fixed\" font");
}
return style->private_font;
}
+/**
+ * gtk_style_get_font:
+ * @style: a #GtkStyle
+ *
+ * Gets the #GdkFont to use for the given style. This is
+ * meant only as a replacement for direct access to @style->font
+ * and should not be used in new code. New code should
+ * use @style->font_desc instead.
+ *
+ * Return value: the #GdkFont for the style. This font is owned
+ * by the style; if you want to keep around a copy, you must
+ * call gdk_font_ref().
+ **/
+GdkFont *
+gtk_style_get_font (GtkStyle *style)
+{
+ g_return_val_if_fail (GTK_IS_STYLE (style), NULL);
+
+ return gtk_style_get_font_for_display (gdk_get_default_display (), style);
+}
+
/**
* gtk_style_set_font:
* @style: a #GtkStyle.
GtkStyle* gtk_style_ref (GtkStyle *style);
void gtk_style_unref (GtkStyle *style);
+#ifndef GDK_MULTIHEAD_SAFE
GdkFont * gtk_style_get_font (GtkStyle *style);
+#endif
+GdkFont * gtk_style_get_font_for_display (GdkDisplay *display,
+ GtkStyle *style);
void gtk_style_set_font (GtkStyle *style,
GdkFont *font);
#endif /* GTK_DISABLE_DEPRECATED */
#define MARK_CURRENT_FONT(text, mark) \
((MARK_CURRENT_PROPERTY(mark)->flags & PROPERTY_FONT) ? \
MARK_CURRENT_PROPERTY(mark)->font->gdk_font : \
- gtk_style_get_font (GTK_WIDGET (text)->style))
+ gtk_style_get_font_for_display (gtk_widget_get_display (GTK_WIDGET (text)), \
+ GTK_WIDGET (text)->style))
#define MARK_CURRENT_FORE(text, mark) \
((MARK_CURRENT_PROPERTY(mark)->flags & PROPERTY_FOREGROUND) ? \
&MARK_CURRENT_PROPERTY(mark)->fore_color : \
if ((TEXT_LENGTH (text) == 0) && (text->use_wchar == FALSE))
{
- GtkWidget *widget;
- widget = GTK_WIDGET (text);
+ GtkWidget *widget = GTK_WIDGET (text);
+
gtk_widget_ensure_style (widget);
- if ((widget->style) && (gtk_style_get_font (widget->style)->type == GDK_FONT_FONTSET))
+ if ((widget->style) &&
+ (gtk_style_get_font_for_display (gtk_widget_get_display (widget), widget->style)->type == GDK_FONT_FONTSET))
{
text->use_wchar = TRUE;
g_free (text->text.ch);
attributes.width = MAX (1, (gint)widget->allocation.width - (gint)attributes.x * 2);
attributes.height = MAX (1, (gint)widget->allocation.height - (gint)attributes.y * 2);
- attributes.cursor = gdk_cursor_new (GDK_XTERM);
+ attributes.cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (widget), GDK_XTERM);
attributes_mask |= GDK_WA_CURSOR;
text->text_area = gdk_window_new (widget->window, &attributes, attributes_mask);
recompute_geometry (text);
}
-
+
if (text->current_font)
text_font_unref (text->current_font);
- text->current_font = get_text_font (gtk_style_get_font (widget->style));
+ text->current_font = get_text_font (gtk_style_get_font_for_display (gtk_widget_get_display (widget), widget->style));
}
static void
xthickness = widget->style->xthickness + TEXT_BORDER_ROOM;
ythickness = widget->style->ythickness + TEXT_BORDER_ROOM;
- font = gtk_style_get_font (widget->style);
+ font = gtk_style_get_font_for_display (gtk_widget_get_display (widget),
+ widget->style);
char_height = MIN_TEXT_HEIGHT_LINES * (font->ascent +
font->descent);
}
else
{
+ GdkDisplay *display = gtk_widget_get_display (widget);
+
gtk_grab_add (widget);
undraw_cursor (text, FALSE);
text->cursor_mark.index);
old_editable->has_selection = FALSE;
- if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == widget->window)
- gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY, event->time);
+ if (gdk_selection_owner_get_for_display (display,
+ GDK_SELECTION_PRIMARY) == widget->window)
+ gtk_selection_owner_set_for_display (display,
+ NULL,
+ GDK_SELECTION_PRIMARY,
+ event->time);
}
}
{
GtkText *text;
GtkOldEditable *old_editable;
+ GdkDisplay *display;
+
g_return_val_if_fail (GTK_IS_TEXT (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
{
text = GTK_TEXT (widget);
old_editable = GTK_OLD_EDITABLE (widget);
+ display = gtk_widget_get_display (widget);
gtk_grab_remove (widget);
old_editable->has_selection = FALSE;
if (old_editable->selection_start_pos != old_editable->selection_end_pos)
{
- if (gtk_selection_owner_set (widget,
- GDK_SELECTION_PRIMARY,
- event->time))
+ if (gtk_selection_owner_set_for_display (display,
+ widget,
+ GDK_SELECTION_PRIMARY,
+ event->time))
old_editable->has_selection = TRUE;
else
gtk_text_update_text (old_editable, old_editable->selection_start_pos,
}
else
{
- if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == widget->window)
- gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY, event->time);
+ if (gdk_selection_owner_get_for_display (display,
+ GDK_SELECTION_PRIMARY) == widget->window)
+ gtk_selection_owner_set_for_display (display,
+ NULL,
+ GDK_SELECTION_PRIMARY,
+ event->time);
}
}
else if (event->button == 3)
GtkTextBuffer *src_buffer = NULL;
/* If we can get the owner, the selection is in-process */
- owner = gdk_selection_owner_get (selection_data->selection);
+ owner = gdk_selection_owner_get_for_display (selection_data->display,
+ selection_data->selection);
if (owner == NULL)
return NULL;
gtk_text_render_state_update (GtkTextRenderState *state,
GtkTextAppearance *new_appearance)
{
+ GdkScreen *screen = gtk_widget_get_screen (state->widget);
+
if (!state->last_appearance ||
!gdk_color_equal (&new_appearance->fg_color, &state->last_appearance->fg_color))
gtk_text_render_state_set_color (state, state->fg_gc, &new_appearance->fg_color);
{
if (new_appearance->fg_stipple)
{
- gdk_gc_set_fill (state->fg_gc, GDK_STIPPLED);
- gdk_gc_set_stipple (state->fg_gc, new_appearance->fg_stipple);
+ if (screen == gdk_drawable_get_screen (new_appearance->fg_stipple))
+ {
+ gdk_gc_set_fill (state->fg_gc, GDK_STIPPLED);
+ gdk_gc_set_stipple (state->fg_gc, new_appearance->fg_stipple);
+ }
+ else
+ g_warning ("gtk_text_render_state_update:\n"
+ "The foreground stipple bitmap has been created on the wrong screen.\n"
+ "Ignoring the stipple bitmap information.");
}
else
{
{
if (new_appearance->bg_stipple)
{
- gdk_gc_set_fill (state->bg_gc, GDK_STIPPLED);
- gdk_gc_set_stipple (state->bg_gc, new_appearance->bg_stipple);
+ if (screen == gdk_drawable_get_screen (new_appearance->bg_stipple))
+ {
+ gdk_gc_set_fill (state->bg_gc, GDK_STIPPLED);
+ gdk_gc_set_stipple (state->bg_gc, new_appearance->bg_stipple);
+ }
+ else
+ g_warning ("gtk_text_render_state_update:\n"
+ "The background stipple bitmap has been created on the wrong screen.\n"
+ "Ignoring the stipple bitmap information.");
+
}
else
{
text_view->dnd_mark = NULL;
if (GTK_WIDGET_REALIZED (text_view))
- gtk_text_buffer_remove_selection_clipboard (text_view->buffer,
- gtk_clipboard_get (GDK_SELECTION_PRIMARY));
+ {
+ GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
+ GDK_SELECTION_PRIMARY);
+ gtk_text_buffer_remove_selection_clipboard (text_view->buffer, clipboard);
+ }
}
text_view->buffer = buffer;
G_CALLBACK (gtk_text_view_mark_set_handler), text_view);
if (GTK_WIDGET_REALIZED (text_view))
- gtk_text_buffer_add_selection_clipboard (text_view->buffer,
- gtk_clipboard_get (GDK_SELECTION_PRIMARY));
+ {
+ GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
+ GDK_SELECTION_PRIMARY);
+ gtk_text_buffer_add_selection_clipboard (text_view->buffer, clipboard);
+ }
}
if (GTK_WIDGET_VISIBLE (text_view))
gtk_text_view_ensure_layout (text_view);
if (text_view->buffer)
- gtk_text_buffer_add_selection_clipboard (text_view->buffer,
- gtk_clipboard_get (GDK_SELECTION_PRIMARY));
+ {
+ GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
+ GDK_SELECTION_PRIMARY);
+ gtk_text_buffer_add_selection_clipboard (text_view->buffer, clipboard);
+ }
tmp_list = text_view->children;
while (tmp_list != NULL)
text_view = GTK_TEXT_VIEW (widget);
if (text_view->buffer)
- gtk_text_buffer_remove_selection_clipboard (text_view->buffer,
- gtk_clipboard_get (GDK_SELECTION_PRIMARY));
+ {
+ GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
+ GDK_SELECTION_PRIMARY);
+ gtk_text_buffer_remove_selection_clipboard (text_view->buffer, clipboard);
+ }
gtk_text_view_remove_validate_idles (text_view);
event->y + text_view->yoffset);
gtk_text_buffer_paste_clipboard (get_buffer (text_view),
- gtk_clipboard_get (GDK_SELECTION_PRIMARY),
+ gtk_widget_get_clipboard (widget, GDK_SELECTION_PRIMARY),
&iter,
text_view->editable);
return TRUE;
gtk_text_view_check_cursor_blink (text_view);
}
- g_signal_connect (gdk_keymap_get_default (),
+ g_signal_connect (gdk_keymap_get_for_display (gtk_widget_get_display (widget)),
"direction_changed",
G_CALLBACK (keymap_direction_changed), text_view);
gtk_text_view_check_keymap_direction (text_view);
gtk_text_view_check_cursor_blink (text_view);
}
- g_signal_handlers_disconnect_by_func (gdk_keymap_get_default (),
- (gpointer) keymap_direction_changed,
- text_view);
+ g_signal_handlers_disconnect_by_func (gdk_keymap_get_for_display (gtk_widget_get_display (widget)),
+ (gpointer) keymap_direction_changed,
+ text_view);
text_view->need_im_reset = TRUE;
gtk_im_context_focus_out (GTK_TEXT_VIEW (widget)->im_context);
{
GdkCursor *cursor;
- cursor = gdk_cursor_new (GDK_XTERM);
+ cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (widget),
+ GDK_XTERM);
gdk_window_set_cursor (text_view->text_window->bin_window, cursor);
gdk_cursor_unref (cursor);
text_view->mouse_cursor_obscured = FALSE;
static void
gtk_text_view_cut_clipboard (GtkTextView *text_view)
{
+ GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
+ GDK_SELECTION_CLIPBOARD);
+
gtk_text_buffer_cut_clipboard (get_buffer (text_view),
- gtk_clipboard_get (GDK_SELECTION_CLIPBOARD),
+ clipboard,
text_view->editable);
DV(g_print (G_STRLOC": scrolling onscreen\n"));
gtk_text_view_scroll_mark_onscreen (text_view,
static void
gtk_text_view_copy_clipboard (GtkTextView *text_view)
{
+ GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
+ GDK_SELECTION_CLIPBOARD);
+
gtk_text_buffer_copy_clipboard (get_buffer (text_view),
- gtk_clipboard_get (GDK_SELECTION_CLIPBOARD));
+ clipboard);
DV(g_print (G_STRLOC": scrolling onscreen\n"));
gtk_text_view_scroll_mark_onscreen (text_view,
gtk_text_buffer_get_mark (get_buffer (text_view),
static void
gtk_text_view_paste_clipboard (GtkTextView *text_view)
{
+ GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
+ GDK_SELECTION_CLIPBOARD);
+
gtk_text_buffer_paste_clipboard (get_buffer (text_view),
- gtk_clipboard_get (GDK_SELECTION_CLIPBOARD),
+ clipboard,
NULL,
text_view->editable);
DV(g_print (G_STRLOC": scrolling onscreen\n"));
"gtk-split-cursor", &split_cursor,
NULL);
if (split_cursor)
- new_dir = GTK_TEXT_DIR_NONE;
+ {
+ new_dir = GTK_TEXT_DIR_NONE;
+ }
else
- new_dir = (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
- GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
+ {
+ GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (text_view)));
+ new_dir = (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_LTR) ?
+ GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
+ }
if (text_view->layout->cursor_direction != new_dir)
gtk_text_layout_set_cursor_direction (text_view->layout, new_dir);
gint root_x, root_y;
GtkTextIter iter;
GtkRequisition req;
+ GdkScreen *screen;
text_view = GTK_TEXT_VIEW (user_data);
widget = GTK_WIDGET (text_view);
g_return_if_fail (GTK_WIDGET_REALIZED (text_view));
+
+ screen = gtk_widget_get_screen (widget);
gdk_window_get_origin (widget->window, &root_x, &root_y);
*x = CLAMP (*x, root_x, (root_x + widget->allocation.width));
*y = CLAMP (*y, root_y, (root_y + widget->allocation.height));
- *x = CLAMP (*x, 0, MAX (0, gdk_screen_width () - req.width));
- *y = CLAMP (*y, 0, MAX (0, gdk_screen_height () - req.height));
+ *x = CLAMP (*x, 0, MAX (0, gdk_screen_get_width (screen) - req.width));
+ *y = CLAMP (*y, 0, MAX (0, gdk_screen_get_height (screen) - req.height));
}
typedef struct
info->time = gtk_get_current_event_time ();
}
- gtk_clipboard_request_contents (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD),
+ gtk_clipboard_request_contents (gtk_widget_get_clipboard (GTK_WIDGET (text_view),
+ GDK_SELECTION_CLIPBOARD),
gdk_atom_intern ("TARGETS", FALSE),
popup_targets_received,
info);
if (win->type == GTK_TEXT_WINDOW_TEXT)
{
/* I-beam cursor */
- cursor = gdk_cursor_new (GDK_XTERM);
+ cursor = gdk_cursor_new_for_screen (gdk_drawable_get_screen (parent),
+ GDK_XTERM);
gdk_window_set_cursor (win->bin_window, cursor);
gdk_cursor_unref (cursor);
g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
- tips_query->query_cursor = gdk_cursor_new (GDK_QUESTION_ARROW);
+ tips_query->query_cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (GTK_WIDGET (tips_query)),
+ GDK_QUESTION_ARROW);
failure = gdk_pointer_grab (GTK_WIDGET (tips_query)->window,
TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
gtk_grab_remove (GTK_WIDGET (tips_query));
if (tips_query->query_cursor)
{
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (GTK_WIDGET (tips_query)),
+ GDK_CURRENT_TIME);
gdk_cursor_destroy (tips_query->query_cursor);
tips_query->query_cursor = NULL;
}
static void gtk_toolbar_class_init (GtkToolbarClass *class);
static void gtk_toolbar_init (GtkToolbar *toolbar);
-static void gtk_toolbar_finalize (GObject *object);
static void gtk_toolbar_set_property (GObject *object,
guint prop_id,
const GValue *value,
GtkStyle *prev_style);
static gboolean gtk_toolbar_focus (GtkWidget *widget,
GtkDirectionType dir);
+static void gtk_toolbar_hierarchy_changed (GtkWidget *widget,
+ GtkWidget *previous_toplevel);
static void gtk_toolbar_show_all (GtkWidget *widget);
static void gtk_toolbar_add (GtkContainer *container,
GtkWidget *widget);
parent_class = gtk_type_class (gtk_container_get_type ());
- gobject_class->finalize = gtk_toolbar_finalize;
-
object_class->destroy = gtk_toolbar_destroy;
gobject_class->set_property = gtk_toolbar_set_property;
gobject_class->get_property = gtk_toolbar_get_property;
widget_class->style_set = gtk_toolbar_style_set;
widget_class->show_all = gtk_toolbar_show_all;
widget_class->focus = gtk_toolbar_focus;
+ widget_class->hierarchy_changed = gtk_toolbar_hierarchy_changed;
container_class->add = gtk_toolbar_add;
container_class->remove = gtk_toolbar_remove;
}
static void
-style_change_notify (GObject *object,
- GParamSpec *pspec,
- gpointer data)
+style_change_notify (GtkToolbar *toolbar)
{
- GtkToolbar *toolbar;
-
- toolbar = GTK_TOOLBAR (data);
-
if (!toolbar->style_set)
{
/* pretend it was set, then unset, thus reverting to new default */
}
static void
-icon_size_change_notify (GObject *object,
- GParamSpec *pspec,
- gpointer data)
+icon_size_change_notify (GtkToolbar *toolbar)
{
- GtkToolbar *toolbar;
-
- toolbar = GTK_TOOLBAR (data);
-
if (!toolbar->icon_size_set)
{
/* pretend it was set, then unset, thus reverting to new default */
}
}
+static void
+toolbar_screen_changed (GtkToolbar *toolbar)
+{
+ GtkSettings *old_settings = g_object_get_data (G_OBJECT (toolbar), "gtk-toolbar-settings");
+ GtkSettings *settings;
+
+ if (gtk_widget_has_screen (GTK_WIDGET (toolbar)))
+ settings = gtk_widget_get_settings (GTK_WIDGET (toolbar));
+ else
+ settings = NULL;
+
+ if (settings == old_settings)
+ return;
+
+ if (old_settings)
+ {
+ g_signal_handler_disconnect (old_settings, toolbar->style_set_connection);
+ g_signal_handler_disconnect (old_settings, toolbar->icon_size_connection);
+
+ g_object_unref (old_settings);
+ }
+
+ if (settings)
+ {
+ toolbar->style_set_connection = g_signal_connect_swapped (settings,
+ "notify::gtk-toolbar-style",
+ G_CALLBACK (style_change_notify),
+ toolbar);
+
+ toolbar->icon_size_connection = g_signal_connect_swapped (settings,
+ "notify::gtk-toolbar-icon-size",
+ G_CALLBACK (icon_size_change_notify),
+ toolbar);
+
+
+ g_object_ref (settings);
+ g_object_set_data (G_OBJECT (toolbar), "gtk-toolbar-settings", settings);
+
+ style_change_notify (toolbar);
+ icon_size_change_notify (toolbar);
+ }
+ else
+ g_object_set_data (G_OBJECT (toolbar), "gtk-toolbar-settings", NULL);
+}
+
+static void
+gtk_toolbar_hierarchy_changed (GtkWidget *widget,
+ GtkWidget *previous_toplevel)
+{
+ GtkWidget *toplevel;
+
+ if (previous_toplevel)
+ g_signal_handlers_disconnect_by_func (previous_toplevel,
+ (gpointer) toolbar_screen_changed,
+ widget);
+
+ toplevel = gtk_widget_get_toplevel (widget);
+ if (GTK_WIDGET_TOPLEVEL (toplevel))
+ g_signal_connect_swapped (toplevel,
+ "notify::screen",
+ G_CALLBACK (toolbar_screen_changed),
+ widget);
+
+ toolbar_screen_changed (GTK_TOOLBAR (widget));
+}
+
static void
gtk_toolbar_init (GtkToolbar *toolbar)
{
toolbar->style_set = FALSE;
toolbar->icon_size_set = FALSE;
- g_object_get (gtk_settings_get_default (),
- "gtk-toolbar-icon-size",
- &toolbar->icon_size,
- "gtk-toolbar-style",
- &toolbar->style,
- NULL);
-
- toolbar->style_set_connection =
- g_signal_connect (G_OBJECT (gtk_settings_get_default ()),
- "notify::gtk-toolbar-style",
- G_CALLBACK (style_change_notify),
- toolbar);
-
- toolbar->icon_size_connection =
- g_signal_connect (G_OBJECT (gtk_settings_get_default ()),
- "notify::gtk-toolbar-icon-size",
- G_CALLBACK (icon_size_change_notify),
- toolbar);
-}
-
-static void
-gtk_toolbar_finalize (GObject *object)
-{
- GtkToolbar *toolbar;
-
- toolbar = GTK_TOOLBAR (object);
-
- g_signal_handler_disconnect (G_OBJECT (gtk_settings_get_default ()),
- toolbar->style_set_connection);
- g_signal_handler_disconnect (G_OBJECT (gtk_settings_get_default ()),
- toolbar->icon_size_connection);
-
- G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
if (toolbar->icon_size_set)
{
- g_object_get (gtk_settings_get_default (),
- "gtk-toolbar-icon-size",
- &size, NULL);
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (toolbar)),
+ "gtk-toolbar-icon-size", &size,
+ NULL);
if (size != toolbar->icon_size)
gtk_toolbar_set_icon_size (toolbar, size);
if (toolbar->style_set)
{
- g_object_get (gtk_settings_get_default (),
- "gtk-toolbar-style",
- &style,
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (toolbar)),
+ "gtk-toolbar-style", &style,
NULL);
if (style != toolbar->style)
if (!tooltips->tip_window)
{
tooltips->tip_window = gtk_window_new (GTK_WINDOW_POPUP);
+ gtk_window_set_screen (GTK_WINDOW (tooltips->tip_window),
+ gtk_widget_get_screen (tooltips->active_tips_data->widget));
gtk_widget_set_app_paintable (tooltips->tip_window, TRUE);
gtk_window_set_policy (GTK_WINDOW (tooltips->tip_window), FALSE, FALSE, TRUE);
gtk_widget_set_name (tooltips->tip_window, "gtk-tooltips");
gint x, y, w, h, scr_w, scr_h;
GtkTooltipsData *data;
gboolean keyboard_mode;
+ GdkScreen *screen;
if (!tooltips->tip_window)
gtk_tooltips_force_window (tooltips);
widget = tooltips->active_tips_data->widget;
keyboard_mode = get_keyboard_mode (widget);
-
- scr_w = gdk_screen_width ();
- scr_h = gdk_screen_height ();
+
+ screen = gtk_widget_get_screen (widget);
+ scr_w = gdk_screen_get_width (screen);
+ scr_h = gdk_screen_get_height (screen);
data = tooltips->active_tips_data;
x += widget->allocation.width / 2;
if (!keyboard_mode)
- gdk_window_get_pointer (NULL, &x, NULL, NULL);
+ gdk_window_get_pointer (gdk_screen_get_root_window (screen),
+ &x, NULL, NULL);
x -= (w / 2 + 4);
tree_view = GTK_TREE_VIEW (widget);
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
- gdk_keyboard_ungrab (GDK_CURRENT_TIME);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME);
+ gdk_display_keyboard_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME);
/* Move the button back */
g_object_ref (tree_view->priv->drag_column->button);
GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE);
gtk_widget_get_pointer (widget, &x, NULL);
gtk_grab_remove (widget);
- gdk_pointer_ungrab (event->time);
-
+ gdk_display_pointer_ungrab (gdk_drawable_get_display (event->window),
+ event->time);
return TRUE;
}
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
attributes.width = width;
attributes.height = height;
- tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
+ tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
+ &attributes, attributes_mask);
gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width, height, 1);
GdkEvent send_event;
GtkAllocation allocation;
gint x, y, width, height;
+ GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
g_return_if_fail (tree_view->priv->column_drag_info == NULL);
gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
}
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
- gdk_keyboard_ungrab (GDK_CURRENT_TIME);
+ gdk_display_pointer_ungrab (gdk_screen_get_display (screen), GDK_CURRENT_TIME);
+ gdk_display_keyboard_ungrab (gdk_screen_get_display (screen), GDK_CURRENT_TIME);
gtk_grab_remove (column->button);
gtk_propagate_event (column->button, &send_event);
send_event.button.type = GDK_BUTTON_RELEASE;
- send_event.button.window = GDK_ROOT_PARENT ();
+ send_event.button.window = gdk_screen_get_root_window (screen);
send_event.button.send_event = TRUE;
send_event.button.time = GDK_CURRENT_TIME;
send_event.button.x = -1;
gboolean collapse;
gint x, y;
GList *list;
+ GdkScreen *screen;
if (node->children == NULL)
return FALSE;
/* now that we've collapsed all rows, we want to try to set the prelight
* again. To do this, we fake a motion event and send it to ourselves. */
- if (gdk_window_at_pointer (&x, &y) == tree_view->priv->bin_window)
+ screen = gdk_drawable_get_screen (tree_view->priv->bin_window);
+ if (gdk_screen_get_window_at_pointer (screen, &x, &y) == tree_view->priv->bin_window)
{
GdkEventMotion event;
event.window = tree_view->priv->bin_window;
gint tree_x, tree_y;
gint tree_width, tree_height;
GdkWindow *tree_window = GTK_WIDGET (tree_view)->window;
+ GdkScreen *screen = gdk_drawable_get_screen (tree_window);
GtkRequisition requisition;
gtk_widget_realize (search_dialog);
&tree_height);
gtk_widget_size_request (search_dialog, &requisition);
- if (tree_x + tree_width - requisition.width > gdk_screen_width ())
- x = gdk_screen_width () - requisition.width;
+ if (tree_x + tree_width - requisition.width > gdk_screen_get_width (screen))
+ x = gdk_screen_get_width (screen) - requisition.width;
else if (tree_x + tree_width - requisition.width < 0)
x = 0;
else
x = tree_x + tree_width - requisition.width;
- if (tree_y + tree_height > gdk_screen_height ())
- y = gdk_screen_height () - requisition.height;
+ if (tree_y + tree_height > gdk_screen_get_height (screen))
+ y = gdk_screen_get_height (screen) - requisition.height;
else if (tree_y + tree_height < 0) /* isn't really possible ... */
y = 0;
else
GDK_POINTER_MOTION_HINT_MASK |
GDK_KEY_PRESS_MASK);
attributes_mask = GDK_WA_CURSOR | GDK_WA_X | GDK_WA_Y;
- attr.cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
-
+ attr.cursor = gdk_cursor_new_for_screen (gdk_drawable_get_screen (tree_view->priv->header_window),
+ GDK_SB_H_DOUBLE_ARROW);
attr.y = 0;
attr.width = TREE_VIEW_DRAG_WIDTH;
attr.height = tree_view->priv->header_height;
#include <locale.h>
#include "gtkcontainer.h"
#include "gtkaccelmap.h"
+#include "gtkclipboard.h"
#include "gtkiconfactory.h"
#include "gtkintl.h"
#include "gtkmain.h"
#include "gtkintl.h"
#include "gtkaccessible.h"
#include "gtktooltips.h"
+#include "gtkinvisible.h"
#define WIDGET_CLASS(w) GTK_WIDGET_GET_CLASS (w)
#define INIT_PATH_SIZE (512)
static gpointer parent_class = NULL;
static guint widget_signals[LAST_SIGNAL] = { 0 };
static GMemChunk *aux_info_mem_chunk = NULL;
-static GdkColormap *default_colormap = NULL;
static GtkStyle *gtk_default_style = NULL;
static GSList *colormap_stack = NULL;
static guint composite_child_stack = 0;
{
g_warning ("widget `%s' isn't suitable for mnemonic activation",
G_OBJECT_TYPE_NAME (widget));
- gdk_beep ();
+ gdk_display_beep (gtk_widget_get_display (widget));
}
return TRUE;
}
static void
gtk_widget_reset_rc_style (GtkWidget *widget)
{
- GtkStyle *new_style;
+ GtkStyle *new_style = NULL;
gboolean initial_emission;
g_return_if_fail (GTK_IS_WIDGET (widget));
GTK_PRIVATE_UNSET_FLAG (widget, GTK_USER_STYLE);
GTK_WIDGET_SET_FLAGS (widget, GTK_RC_STYLE);
-
- new_style = gtk_rc_get_style (widget);
+
+ if (gtk_widget_has_screen (widget))
+ new_style = gtk_rc_get_style (widget);
if (!new_style)
new_style = gtk_widget_get_default_style ();
gtk_widget_get_pango_context (GtkWidget *widget)
{
PangoContext *context;
+ GdkScreen *screen;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
context = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_pango_context);
+ if (context)
+ {
+ screen = g_object_get_data (G_OBJECT (context), "gdk-pango-screen");
+ if (screen && (screen != gtk_widget_get_screen (widget)))
+ context = NULL;
+ }
+
if (!context)
{
context = gtk_widget_create_pango_context (GTK_WIDGET (widget));
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
- context = gdk_pango_context_get ();
+ context = gdk_pango_context_get_for_screen (gtk_widget_get_screen (widget));
gdk_pango_context_set_colormap (context, gtk_widget_get_colormap (widget));
pango_context_set_base_dir (context,
return GTK_WIDGET_CHILD_VISIBLE (widget);
}
+static GdkScreen *
+gtk_widget_get_screen_unchecked (GtkWidget *widget)
+{
+ GtkWidget *toplevel;
+
+ toplevel = gtk_widget_get_toplevel (widget);
+
+ if (GTK_WIDGET_TOPLEVEL (toplevel))
+ {
+ if (GTK_IS_WINDOW (toplevel))
+ return GTK_WINDOW (toplevel)->screen;
+ else if (GTK_IS_INVISIBLE (toplevel))
+ return GTK_INVISIBLE (widget)->screen;
+ }
+
+ return NULL;
+}
+
+/**
+ * gtk_widget_get_screen:
+ * @widget: a #GtkWidget
+ *
+ * Get the #GdkScreen from the toplevel window associated with
+ * this widget. This function can only be called after the widget
+ * has been added to a widget heirarchy with a #GtkWindow
+ * at the top.
+ *
+ * In general, you should only create screen specific
+ * resources when a widget has been realized, and you should
+ * free those resources when the widget is unrealized.
+ *
+ * Return value: the #GdkScreen for the toplevel for this widget.
+ **/
+GdkScreen*
+gtk_widget_get_screen (GtkWidget *widget)
+{
+ GdkScreen *screen;
+
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+ screen = gtk_widget_get_screen_unchecked (widget);
+
+ if (screen)
+ return screen;
+ else
+ {
+#if 0
+ g_warning (G_STRLOC ": Can't get associated screen"
+ " for a widget unless it is inside a toplevel GtkWindow\n"
+ " widget type is %s associated top level type is %s",
+ g_type_name (G_OBJECT_TYPE(G_OBJECT (widget))),
+ g_type_name (G_OBJECT_TYPE(G_OBJECT (toplevel))));
+#endif
+ return gdk_get_default_screen ();
+ }
+}
+
+/**
+ * gtk_widget_has_screen:
+ * @widget: a #GtkWidget
+ *
+ * Checks whether there is a #GdkScreen is associated with
+ * this widget. All toplevel widgets have an associated
+ * screen, and all widgets added into a heirarchy with a toplevel
+ * window at the top.
+ *
+ * Return value: %TRUE if there is a #GdkScreen assoicated
+ * with the widget.
+ **/
+gboolean
+gtk_widget_has_screen (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return (gtk_widget_get_screen_unchecked (widget) != NULL);
+}
+
+/**
+ * gtk_widget_get_display:
+ * @widget: a #GtkWidget
+ *
+ * Get the #GdkDisplay for the toplevel window associated with
+ * this widget. This function can only be called after the widget
+ * has been added to a widget hierarchy with a #GtkWindow at the top.
+ *
+ * In general, you should only create display specific
+ * resources when a widget has been realized, and you should
+ * free those resources when the widget is unrealized.
+ *
+ * Return value: the #GdkDisplay for the toplevel for this widget.
+ **/
+GdkDisplay*
+gtk_widget_get_display (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+ return gdk_screen_get_display (gtk_widget_get_screen (widget));
+}
+
+/**
+ * gtk_widget_get_root_window:
+ * @widget: a #GtkWidget
+ *
+ * Get the root window where this widget is located. This function can
+ * only be called after the widget has been added to a widget
+ * heirarchy with #GtkWindow at the top.
+ *
+ * The root window is useful for such purposes as creating a popup
+ * #GdkWindow associated with the window. In general, you should only
+ * create display specific resources when a widget has been realized,
+ * and you should free those resources when the widget is unrealized.
+ *
+ * Return value: the #GdkWindow root window for the toplevel for this widget.
+ **/
+GdkWindow*
+gtk_widget_get_root_window (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+ return gdk_screen_get_root_window (gtk_widget_get_screen (widget));
+}
+
/**
* gtk_widget_get_parent_window:
* @widget: a #GtkWidget.
gtk_widget_get_colormap (GtkWidget *widget)
{
GdkColormap *colormap;
+ GtkWidget *tmp_widget;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return colormap;
}
- while (widget)
+ tmp_widget = widget;
+ while (tmp_widget)
{
- colormap = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_colormap);
+ colormap = gtk_object_get_data_by_id (GTK_OBJECT (tmp_widget), quark_colormap);
if (colormap)
return colormap;
- widget = widget->parent;
+ tmp_widget= tmp_widget->parent;
}
- return gtk_widget_get_default_colormap ();
+ return gdk_screen_get_default_colormap (gtk_widget_get_screen (widget));
}
/**
*
* Gets the settings object holding the settings (global property
* settings, RC file information, etc) used for this widget.
+ *
+ * Note that this function can only be called when the #GtkWidget
+ * is attached to a toplevel, since the settings object is specific
+ * to a particular #GdkScreen.
*
* Return value: the relevant #GtkSettings object
**/
GtkSettings*
gtk_widget_get_settings (GtkWidget *widget)
{
- return gtk_settings_get_default ();
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+ return gtk_settings_get_for_screen (gtk_widget_get_screen (widget));
}
/**
{
g_return_if_fail (GDK_IS_COLORMAP (colormap));
- if (default_colormap != colormap)
- {
- if (default_colormap)
- gdk_colormap_unref (default_colormap);
- default_colormap = colormap;
- if (default_colormap)
- gdk_colormap_ref (default_colormap);
- }
+ gdk_screen_set_default_colormap (colormap->screen, colormap);
}
/**
GdkColormap*
gtk_widget_get_default_colormap (void)
{
- if (!default_colormap)
- gtk_widget_set_default_colormap (gdk_rgb_get_colormap ());
-
- return default_colormap;
+ return gdk_screen_get_default_colormap (gdk_get_default_screen ());
}
/**
g_object_ref (G_OBJECT (accessible));
return accessible;
}
+
+/**
+ * gtk_widget_get_clipboard:
+ * @widget: a #GtkWidget
+ * @selection: a #GdkAtom which identifies the clipboard
+ * to use. %GDK_SELECTION_CLIPBOARD gives the
+ * default clipboard. Another common value
+ * is %GDK_SELECTION_PRIMARY, which gives
+ * the primary X selection.
+ *
+ * Returns the clipboard object for the given selection to
+ * be used with @widget. @widget must have a #GdkDisplay
+ * associated with it, so must be attached to a toplevel
+ * window.
+ *
+ * Return value: the appropriate clipboard object. If no
+ * clipboard already exists, a new one will
+ * be created. Once a clipboard object has
+ * been created, it is persistent for all time.
+ **/
+GtkClipboard *
+gtk_widget_get_clipboard (GtkWidget *widget, GdkAtom selection)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+ g_return_val_if_fail (gtk_widget_has_screen (widget), NULL);
+
+ return gtk_clipboard_get_for_display (gtk_widget_get_display (widget),
+ selection);
+}
typedef struct _GtkWidgetClass GtkWidgetClass;
typedef struct _GtkWidgetAuxInfo GtkWidgetAuxInfo;
typedef struct _GtkWidgetShapeInfo GtkWidgetShapeInfo;
+typedef struct _GtkClipboard GtkClipboard;
typedef void (*GtkCallback) (GtkWidget *widget,
gpointer data);
GtkWidget *gtk_widget_get_parent (GtkWidget *widget);
GdkWindow *gtk_widget_get_parent_window (GtkWidget *widget);
+
gboolean gtk_widget_child_focus (GtkWidget *widget,
GtkDirectionType direction);
GdkColormap* gtk_widget_get_colormap (GtkWidget *widget);
GdkVisual* gtk_widget_get_visual (GtkWidget *widget);
-GtkSettings* gtk_widget_get_settings (GtkWidget *widget);
+GdkScreen * gtk_widget_get_screen (GtkWidget *widget);
+gboolean gtk_widget_has_screen (GtkWidget *widget);
+GdkDisplay * gtk_widget_get_display (GtkWidget *widget);
+GdkWindow * gtk_widget_get_root_window (GtkWidget *widget);
+GtkSettings* gtk_widget_get_settings (GtkWidget *widget);
+GtkClipboard *gtk_widget_get_clipboard (GtkWidget *widget,
+ GdkAtom selection);
#ifndef GTK_DISABLE_DEPRECATED
#define gtk_widget_set_visual(widget,visual) ((void) 0)
*/
void gtk_widget_set_default_colormap (GdkColormap *colormap);
GtkStyle* gtk_widget_get_default_style (void);
+#ifndef GDK_MULTIHEAD_SAFE
GdkColormap* gtk_widget_get_default_colormap (void);
GdkVisual* gtk_widget_get_default_visual (void);
+#endif
/* Functions for setting directionality for widgets
*/
GdkColormap* _gtk_widget_peek_colormap (void);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
PROP_DEFAULT_HEIGHT,
PROP_DESTROY_WITH_PARENT,
PROP_ICON,
+ PROP_SCREEN,
LAST_ARG
};
static GtkBinClass *parent_class = NULL;
static guint window_signals[LAST_SIGNAL] = { 0 };
static GList *default_icon_list = NULL;
-/* FIXME need to be per-screen */
-static GdkPixmap *default_icon_pixmap = NULL;
-static GdkPixmap *default_icon_mask = NULL;
+static guint default_icon_serial = 0;
static void gtk_window_set_property (GObject *object,
guint prop_id,
GDK_TYPE_PIXBUF,
G_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class,
+ PROP_SCREEN,
+ g_param_spec_object ("screen",
+ _("Screen"),
+ _("The screen where this window will be displayed."),
+ GDK_TYPE_SCREEN,
+ G_PARAM_READWRITE));
+
window_signals[SET_FOCUS] =
g_signal_new ("set_focus",
G_TYPE_FROM_CLASS (object_class),
window->gravity = GDK_GRAVITY_NORTH_WEST;
window->decorated = TRUE;
window->mnemonic_modifier = GDK_MOD1_MASK;
+ window->screen = gdk_get_default_screen ();
colormap = _gtk_widget_peek_colormap ();
if (colormap)
gtk_window_set_icon (window,
g_value_get_object (value));
break;
-
+ case PROP_SCREEN:
+ gtk_window_set_screen (window, g_value_get_object (value));
+ break;
default:
break;
}
case PROP_ICON:
g_value_set_object (value, gtk_window_get_icon (window));
break;
+ case PROP_SCREEN:
+ g_value_set_object (value, window->screen);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
gtk_signal_connect (GTK_OBJECT (parent), "unrealize",
GTK_SIGNAL_FUNC (gtk_window_transient_parent_unrealized),
window);
+
+ window->screen = parent->screen;
if (window->destroy_with_parent)
connect_parent_destroyed (window);
return info;
}
+typedef struct {
+ guint serial;
+ GdkPixmap *pixmap;
+ GdkPixmap *mask;
+} ScreenIconInfo;
+
+ScreenIconInfo *
+get_screen_icon_info (GdkScreen *screen)
+{
+ ScreenIconInfo *info = g_object_get_data (G_OBJECT (screen),
+ "gtk-window-default-icon-pixmap");
+ if (!info)
+ {
+ info = g_new0 (ScreenIconInfo, 1);
+ g_object_set_data (G_OBJECT (screen), "gtk-window-default-icon-pixmap", info);
+ }
+
+ if (info->serial != default_icon_serial)
+ {
+ if (info->pixmap)
+ {
+ g_object_remove_weak_pointer (G_OBJECT (info->pixmap), (gpointer*)&info->pixmap);
+ info->pixmap = NULL;
+ }
+
+ if (info->mask)
+ {
+ g_object_remove_weak_pointer (G_OBJECT (info->mask), (gpointer*)&info->mask);
+ info->mask = NULL;
+ }
+
+ info->serial = default_icon_serial;
+ }
+
+ return info;
+}
+
static void
-get_pixmap_and_mask (GtkWindowIconInfo *parent_info,
+get_pixmap_and_mask (GdkWindow *window,
+ GtkWindowIconInfo *parent_info,
gboolean is_default_list,
GList *icon_list,
GdkPixmap **pmap_return,
GdkBitmap **mask_return)
{
+ GdkScreen *screen = gdk_drawable_get_screen (window);
+ ScreenIconInfo *default_icon_info = get_screen_icon_info (screen);
GdkPixbuf *best_icon;
GList *tmp_list;
int best_size;
-
+
*pmap_return = NULL;
*mask_return = NULL;
if (is_default_list &&
- default_icon_pixmap != NULL)
+ default_icon_info->pixmap != NULL)
{
- /* Use shared icon pixmap (eventually will be stored on the
- * GdkScreen)
+ /* Use shared icon pixmap for all windows on this screen.
*/
- if (default_icon_pixmap)
- g_object_ref (G_OBJECT (default_icon_pixmap));
- if (default_icon_mask)
- g_object_ref (G_OBJECT (default_icon_mask));
-
- *pmap_return = default_icon_pixmap;
- *mask_return = default_icon_mask;
+ if (default_icon_info->pixmap)
+ g_object_ref (G_OBJECT (default_icon_info->pixmap));
+ if (default_icon_info->mask)
+ g_object_ref (G_OBJECT (default_icon_info->mask));
+
+ *pmap_return = default_icon_info->pixmap;
+ *mask_return = default_icon_info->mask;
}
else if (parent_info && parent_info->icon_pixmap)
{
if (best_icon)
gdk_pixbuf_render_pixmap_and_mask_for_colormap (best_icon,
- gdk_colormap_get_system (),
+ gdk_screen_get_system_colormap (screen),
pmap_return,
mask_return,
128);
}
else if (is_default_list)
{
- default_icon_pixmap = *pmap_return;
- default_icon_mask = *mask_return;
-
- if (default_icon_pixmap)
- g_object_add_weak_pointer (G_OBJECT (default_icon_pixmap),
- (gpointer*)&default_icon_pixmap);
- if (default_icon_mask)
- g_object_add_weak_pointer (G_OBJECT (default_icon_mask),
- (gpointer*)&default_icon_mask);
+ default_icon_info->pixmap = *pmap_return;
+ default_icon_info->mask = *mask_return;
+
+ if (default_icon_info->pixmap)
+ g_object_add_weak_pointer (G_OBJECT (default_icon_info->pixmap),
+ (gpointer*)&default_icon_info->pixmap);
+ if (default_icon_info->mask)
+ g_object_add_weak_pointer (G_OBJECT (default_icon_info->mask),
+ (gpointer*)&default_icon_info->mask);
}
}
}
gdk_window_set_icon_list (widget->window, icon_list);
- get_pixmap_and_mask (info->using_parent_icon ?
- ensure_icon_info (window->transient_parent) : NULL,
+ get_pixmap_and_mask (widget->window,
+ info->using_parent_icon ? ensure_icon_info (window->transient_parent) : NULL,
info->using_default_icon,
icon_list,
&info->icon_pixmap,
if (list == default_icon_list)
return;
- if (default_icon_pixmap)
- g_object_unref (G_OBJECT (default_icon_pixmap));
- if (default_icon_mask)
- g_object_unref (G_OBJECT (default_icon_mask));
-
- default_icon_pixmap = NULL;
- default_icon_mask = NULL;
+ /* Update serial so we don't used cached pixmaps/masks
+ */
+ default_icon_serial++;
g_list_foreach (default_icon_list,
(GFunc) g_object_unref, NULL);
attributes_mask = GDK_WA_VISUAL | GDK_WA_COLORMAP;
- window->frame = gdk_window_new (NULL, &attributes, attributes_mask);
+ window->frame = gdk_window_new (gtk_widget_get_root_window (widget),
+ &attributes, attributes_mask);
+
gdk_window_set_user_data (window->frame, widget);
attributes.window_type = GDK_WINDOW_CHILD;
else
{
attributes_mask = 0;
- parent_window = NULL;
+ parent_window = gtk_widget_get_root_window (widget);
}
attributes.width = widget->allocation.width;
attributes_mask |= GDK_WA_VISUAL | GDK_WA_COLORMAP;
attributes_mask |= (window->title ? GDK_WA_TITLE : 0);
attributes_mask |= (window->wmclass_name ? GDK_WA_WMCLASS : 0);
+
widget->window = gdk_window_new (parent_window, &attributes, attributes_mask);
+
gdk_window_set_user_data (widget->window, window);
widget->style = gtk_style_attach (widget->style, widget->window);
while (embedded_windows)
{
guint xid = GPOINTER_TO_UINT (embedded_windows->data);
- gdk_event_send_client_message ((GdkEvent *) &sev, xid);
+ gdk_event_send_client_message_for_display (gtk_widget_get_display (widget), (GdkEvent *) &sev, xid);
embedded_windows = embedded_windows->next;
}
}
- gtk_rc_reparse_all ();
+ gtk_rc_reparse_all_for_settings (gtk_widget_get_settings (widget), FALSE);
}
static gint
case GTK_WIN_POS_CENTER_ALWAYS:
case GTK_WIN_POS_CENTER:
{
- gint screen_width = gdk_screen_width ();
- gint screen_height = gdk_screen_height ();
-
- x = (screen_width - w) / 2;
- y = (screen_height - h) / 2;
+ gint px, py, monitor_num;
+ GdkRectangle *monitor;
+
+ gdk_window_get_pointer (gdk_screen_get_root_window (window->screen),
+ &px, &py, NULL);
+
+ monitor_num = gdk_screen_get_monitor_at_point (window->screen, px, py);
+ if (monitor_num == -1)
+ monitor_num = 0;
+
+ monitor = gdk_screen_get_monitor_geometry (window->screen, monitor_num);
+
+ x = (monitor->width - w) / 2 + monitor->x;
+ y = (monitor->height - h) / 2 + monitor->y;
}
break;
case GTK_WIN_POS_MOUSE:
{
- gint screen_width = gdk_screen_width ();
- gint screen_height = gdk_screen_height ();
+ gint screen_width = gdk_screen_get_width (window->screen);
+ gint screen_height = gdk_screen_get_height (window->screen);
int px, py;
gdk_window_get_pointer (NULL, &px, &py, NULL);
if (window->position == GTK_WIN_POS_CENTER_ALWAYS)
{
gint center_x, center_y;
- gint screen_width = gdk_screen_width ();
- gint screen_height = gdk_screen_height ();
+ gint screen_width = gdk_screen_get_width (window->screen);
+ gint screen_height = gdk_screen_get_height (window->screen);
center_x = (screen_width - new_width) / 2;
center_y = (screen_height - new_height) / 2;
gdk_window_set_geometry_hints (widget->window,
&new_geometry,
new_flags);
-
+
/* handle resizing/moving and widget tree allocation
*/
if (window->configure_notify_received)
new_request.y - window->frame_top,
new_request.width + window->frame_left + window->frame_right,
new_request.height + window->frame_top + window->frame_bottom);
- gdk_window_resize (GTK_WIDGET (window)->window,
+ gdk_window_resize (widget->window,
new_request.width, new_request.height);
}
else
- gdk_window_move_resize (widget->window,
- new_request.x, new_request.y,
- new_request.width, new_request.height);
+ if (widget->window)
+ gdk_window_move_resize (widget->window,
+ new_request.x, new_request.y,
+ new_request.width, new_request.height);
}
else /* only size changed */
{
gdk_window_resize (window->frame,
new_request.width + window->frame_left + window->frame_right,
new_request.height + window->frame_top + window->frame_bottom);
- gdk_window_resize (widget->window,
- new_request.width, new_request.height);
+ if (widget->window)
+ gdk_window_resize (widget->window,
+ new_request.width, new_request.height);
}
/* Increment the number of have-not-yet-received-notify requests */
timestamp);
}
+/**
+ * gtk_window_set_screen:
+ * @window: a #GtkWindow.
+ * @screen: a #GtkScreen.
+ *
+ * Sets the #GdkScreen where the @window will be displayed.
+ * This function has to be called before the @window
+ * object is realized otherwise it will fail.
+ */
+void
+gtk_window_set_screen (GtkWindow *window,
+ GdkScreen *screen)
+{
+ g_return_if_fail (GTK_IS_WINDOW (window));
+ g_return_if_fail (GDK_IS_SCREEN (screen));
+
+ if (GTK_WIDGET_REALIZED (window))
+ {
+ g_warning ("Trying to change the window's screen while widget is visible");
+ return;
+ }
+
+ gtk_window_free_key_hash (window);
+ window->screen = screen;
+}
+/**
+ * gtk_window_get_screen:
+ * @window: a #GtkWindow.
+ *
+ * Returns the #GdkScreen associated with @window.
+ *
+ * Return value: a #GdkScreen.
+ */
+GdkScreen*
+gtk_window_get_screen (GtkWindow *window)
+{
+ g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
+
+ return window->screen;
+}
+
static void
gtk_window_group_class_init (GtkWindowGroupClass *klass)
if (grav == GDK_GRAVITY_SOUTH_WEST ||
grav == GDK_GRAVITY_SOUTH_EAST)
- y = gdk_screen_height () - h + y;
+ y = gdk_screen_get_height (window->screen) - h + y;
if (grav == GDK_GRAVITY_SOUTH_EAST ||
grav == GDK_GRAVITY_NORTH_EAST)
- x = gdk_screen_width () - w + x;
+ x = gdk_screen_get_width (window->screen) - w + x;
/* we don't let you put a window offscreen; maybe some people would
* prefer to be able to, but it's kind of a bogus thing to do.
if (key_hash)
return key_hash;
- key_hash = _gtk_key_hash_new (gdk_keymap_get_default(), (GDestroyNotify)g_free);
+ key_hash = _gtk_key_hash_new (gdk_keymap_get_for_display (gdk_screen_get_display (window->screen)),
+ (GDestroyNotify)g_free);
_gtk_window_keys_foreach (window, add_to_key_hash, key_hash);
g_object_set_data (G_OBJECT (window), "gtk-window-key-hash", key_hash);
guint keys_changed_handler;
GdkModifierType mnemonic_modifier;
- gpointer gtk_reserved1; /* For future GdkScreen * */
+ GdkScreen *screen;
};
struct _GtkWindowClass
GdkGeometry *geometry,
GdkWindowHints geom_mask);
+void gtk_window_set_screen (GtkWindow *window,
+ GdkScreen *screen);
+GdkScreen* gtk_window_get_screen (GtkWindow *window);
+
/* gtk_window_set_has_frame () must be called before realizing the window_*/
void gtk_window_set_has_frame (GtkWindow *window,
gboolean setting);
projects / gtk4.git / commitdiff